<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<div class="blog-content-box" style="margin: 100px;">
    <div class="article-header-box">
        <div class="article-header">
            <div class="article-title-box">
                <h1 class="title-article">阿里Java面经大全（整合版）</h1>
            </div>
            <div class="article-info-box">
                <div class="article-bar-top">
                    <!--文章类型-->
                    <!--原创-->
                    <img class="article-type-img" alt=""
                        src="https://csdnimg.cn/release/phoenix/template/new_img/original.png">
                    <!--翻译-->
                    <!--转载-->
                    <div class="bar-content">
                        <a class="follow-nickName" href="https://me.csdn.net/a724888" target="_blank"
                            rel="noopener">黄小斜</a>
                        <span class="time">2018-08-03 16:10:12</span>
                        <img class="article-read-img article-heard-img" alt=""
                            src="https://csdnimg.cn/release/phoenix/template/new_img/articleRead.png">
                        <span class="read-count">8900</span>
                        <a class="un-collection" id="blog_detail_zk_collection"
                            data-report-click='{"mod":"popu_823","ab":"new"}'>
                            <img class="article-collect-img article-heard-img un-collect-status" style="display:black"
                                alt="" src="https://csdnimg.cn/release/phoenix/template/new_img/collect.png">
                            <img class="article-collect-img article-heard-img collect-status" style="display:none"
                                alt=""
                                src="https://csdnimg.cn/release/phoenix/template/new_img/tobarCollectionActive.png">
                            <span class="name">收藏</span>
                            <span class="get-collection">
                                39 </span>
                        </a>
                    </div>
                </div>
                <div class="up-time"><span>最后发布:2018-08-03 16:10:12</span><span>首发:2018-08-03 16:10:12</span></div>
                <div class="slide-content-box">
                    <div class="all-tags-box">
                    </div>
                    <div class="article-copyright">
                        <div class="creativecommons">
                            <a href="http://creativecommons.org/licenses/by-sa/4.0/" rel="license"></a>
                        </div>
                        <div class="creativecommons">
                            版权声明：本文为博主原创文章，遵循<a href="http://creativecommons.org/licenses/by-sa/4.0/" target="_blank"
                                rel="noopener"> CC 4.0 BY-SA </a>版权协议，转载请附上原文出处链接和本声明。 </div>
                        <div class="article-source-link">
                            本文链接：<a
                                href="https://blog.csdn.net/a724888/article/details/81389605">https://blog.csdn.net/a724888/article/details/81389605</a>
                        </div>
                    </div>
                </div>
                <div class="operating">
                    <a class="href-article-edit slide-toggle">展开</a>
                </div>
            </div>
        </div>
    </div>
    <!--python安装手册结束-->
    <article class="baidu_pl">
        <!--python安装手册开始-->

        <div class="article_content clearfix" id="article_content">
            <link href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-211130ba7a.css"
                rel="stylesheet">
            <div class="markdown_views prism-atom-one-dark" id="content_views">
                <!-- flowchart 箭头图标 勿删 -->
                <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
                    <path id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"
                        stroke-linecap="round" d="M 5 0 L 0 2.5 L 5 5 Z" />
                </svg>
                <p><strong>本文里的面经内容全部来源于牛客网，作为秋招备战复习与查缺补漏时使用。里面部分面经有我的注释和想法，以及部分解答，不一定正确，大家可以查询补充。</strong></p>
                <p>阿里巴巴，三面，java实习<br>
                    昨天晚上11点打电话来，问我可以面试不，我说不可以，然后就约到了今天，<br>
                    1.上来问我项目用的框架，然后问我springmvc里面有的参数的设定，问的是细节，然后问我如果传的多个值是一个对象的属性，问我如何处理，我说直接在后端接收为对象就行了，然后突然问我http怎么传对象，这里有点不明白面试官想问啥，然后就换别的问题了，<br>
                    可以序列化对象为二进制数据，然后在http1.1以上版本传输即可，然后再进行反序列化</p>
                <p>2.数据库索引都有哪些，介绍一下，然后面试官就问我说话的漏洞，感觉会抓住某一个比较突出的词来逼问，这里除非特别清楚，否则就被问死了，我这里有点虚，回答的有点犹豫，<br>
                    b+树，hash索引，b树索引</p>
                <p>3.数据库事务，然后问我mysql三个select不显式声明事务，他们每一条是个事务吗？这里记得有点不清楚，就是问不显式声明事务，select是一个事务吗<br>
                    默认autocommit，每一条都是是一个事务</p>
                <p>4.乐观锁和悲观锁，我说到了cas，然后问我java中有哪些地方用到了cas，然后我说concurrenthashmap，然后是咋用的，这个类是怎么保证线程安全的，他还说了一个put啥东西我没注意，就说不知道。<br>
                    chm，原子类，AQS等。<br>
                    chm在put操作没有冲突时进行cas尝试，直到成功。<br>
                    原子类使用cas执行自加自减操作防止并发问题。<br>
                    AQS的修改state也是使用了cas操作。<br>
                    5.问我序列化，然后问到了远程方法调用，我说没接触过<br>
                    序列化主要是把对象压缩成二进制数据，进行网络传输，rpc就是基于序列化和网络通信编程实现的。<br>
                    6.问我项目是练手还是买钱，他笑着对我说，我也笑了<br>
                    7.dao层是model层吗？这个以前没注意，就说是，也不知道对不对，记得以前面试好像有面试官问我model和pojo的区别<br>
                    差远了。dao是数据持久化层，负责数据库操作，model负责数据模型。<br>
                    8.索引在什么情况下会失效，这个当时有点激动，想了一下没说出来，有点遗憾，<br>
                    前缀匹配，没用用到，函数，判空，&lt;&gt;等<br>
                    今天面试，面试官给人的感觉很强势，会抓你回答问题的漏洞，也根据我的语气问我不熟悉的地方，剩下的问题没想起来，面了30分钟，面试官很nice</p>
                <p>作者：threee<br>
                    链接：https://www.nowcoder.com/discuss/74170?type=2&amp;order=3&amp;pos=411&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里一面</p>
                <p>简单说说在学校做过最有成就感的事情（和技术相关的）<br>
                    开发了一款游戏，搭了一个人博客，写了博客集，做了3个项目。并且在GitHub上有长期记录。<br>
                    你的项目用到了数据库，谈谈对事务的理解<br>
                    事务保证一致性，原子性，隔离性和持久性。<br>
                    假设你要做一个银行app，有可能碰到多个人同时向一个账户打钱的情况，有可能碰到什么问题，如何解决（锁）<br>
                    可能到时同时修改，导致有人修改失败，汇款出现问题，解决方式就是事务或者使用锁。<br>
                    说说乐观锁和悲观锁<br>
                    乐观锁在数据库中就是MVCC，悲观锁就是行锁和表锁。innodb支持行锁，在索引上加锁<br>
                    最近在看什么书<br>
                    大数据，zookeeper，netty。大型中间件，大型分布式，大型网站<br>
                    Java基础（就问了一句==和equals）</p>
                <p>说说现在能写出来哪些排序算法<br>
                    快排，冒泡，选择，归并，插入，堆排序。计数排数，桶排序。</p>
                <p>在学校有没有参加社团之类的<br>
                    有的。</p>
                <p>给定一个文件名，如何在d盘找出来这个文件，说说思路。<br>
                    使用操作系统查找。find -name，locate，whereis</p>
                <p>可以来杭州么（我意向写的北京）<br>
                    能来实习的时间大概是什么时候</p>
                <p>就聊了20分钟，感觉问的都很简单。。<br>
                    然而11号晚上面试的，今天还是面试中，是不是要凉了</p>
                <p>作者：﹏*安分<br>
                    链接：https://www.nowcoder.com/discuss/74151?type=2&amp;order=3&amp;pos=415&amp;page=1<br>
                    来源：牛客网</p>
                <p>1.自我介绍，刚开始，有点懵，两句介绍完了，太不好了，<br>
                    2.项目中自己觉得做的最好的地方，因为自己的项目真的没有啥亮点，都是基本业务层的实现，所以说了个前段的，然后嘴贱说了个redis，被问死，面试官说你猜的还是看别人的，我说猜的，然后就尴尬了。<br>
                    3.java虚拟机类加载机制<br>
                    双亲委派加载<br>
                    4.java中的锁</p>
                <p>5.反射，怎么实现，一激动说成了序列化，<br>
                    因为Java虚拟机会把类加载到方法区，并且保留Class对象作为每个类的元对象，通过这个对象就可以获取该类的信息，从而获取它的方法，构造函数，变量等内容。<br>
                    通过反射，还可以动态地指定实现类，因为反射可以通过配置文件来配置实现类。然后加载该类到方法区，通过构造方法进行实例化。<br>
                    6.数据库的索引，隔离级别几种，分别是啥，然后就没问了，我还以为会让我详细解释一下。</p>
                <p>7.快速排序思想</p>
                <p>8.问我jdk看的第几版，嘴贱了一下，说了<br>
                    1.8，然后问我hashmap默认的数据结构，果不其然问到了红黑树，然后问红黑树插入，果断不会，这太套路了<br>
                    红黑树的增删改查都比较复杂，但是就是先操作，然后进行树的调整，保证几个特性符合要求。<br>
                    1 根节点是黑节点<br>
                    2 红节点不相邻<br>
                    3 根节点到每个叶子节点的黑节点数都相同，于是保证整棵树的平衡性。<br>
                    （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]<br>
                    （4）如果一个节点是红色的，则它的子节点必须是黑色的。</p>
                <p>9.问道spring，问我都用到了哪些里面的东西，我说ioc，本来问我ioc的实现，突然，问我控制反转了什么，最后说完这个，就没问实现了，直接问我还有啥问他。</p>
                <p>控制反转主要为了对象实例化的解耦，只需要写上接口就可以，通过配置文件或者注解将实际对象注入。<br>
                    并且由Spring的bean容器来管理所有的对象。</p>
                <p>感觉不好，开始的项目中的redis自己把自己坑死了，这次面试以前都很开心，这次不知怎么，一点都开心不起来，可能好运用完了</p>
                <p>作者：Murasame<br>
                    链接：https://www.nowcoder.com/discuss/74143?type=2&amp;order=3&amp;pos=416&amp;page=2<br>
                    来源：牛客网</p>
                <p>今天阿里的HR姐姐打电话过来，说这是HR面，然后让我介绍一下自己，说一说大学的经历、做的比较成功的事，然后选一个认为最成功的跟她讲。<br>
                    然后我就说了自认为最成功的是软件工程导论上和同学组队做的javaWeb项目，自己作为组长完成了所有后台代码、数据库设计，前端由其他组员完成。</p>
                <p>HR姐姐问了项目是怎么开始的，怎么开发的，最后结果如何，遇到了什么困难，组员工作协调得如何。</p>
                <p>我就说有些组员的工作完成的有些敷衍，最后不足的部分是我完善的。</p>
                <p>HR就这点开始问我各种组长的工作，你把前端的任务交给组员时是怎么想的（我说我以后打算从事服务器后台那方面的开发，所以<br>
                    把前端的任务交给组员来做了）</p>
                <p>组员做不好的理由？如果能重来你打算怎么办？</p>
                <p>（我说有组员技术不过关，其他课程任务也多，没花去学，到任务要上交的时候只好敷衍了事，也有我的原因，我没有花时间去指导他们，只是让他们看几个简单例子，如果能重来<br>
                    我会好好指导他们怎么开发…）</p>
                <p>项目最后怎样了？你感觉有什么不足？</p>
                <p>把项目部署到云服务器上，让老师验收，取得不错的成绩。我感觉前端页面做的太简单，基本就是文字+几个按钮，后台的代码有些地方实现的不好。<br>
                    然后HR姐姐就问完了，电话一挂，吃个饭，看进度变为已回绝。</p>
                <p>个人觉得应该是组员的工作没协调好，让HR姐姐不满意了，还有就是把项目不满意的地方大多都归结在其他组员做的部分。</p>
                <p>之前看了些HR的面经，就有人说HR面不能坦诚相待，要把规避短处，我就不应该把项目中组员没好好完成任务，锅全部我来背这件事说出来。<br>
                    吃饭时就感觉不安了，觉得说这些不好，结果真的挂了，好难受。</p>
                <p>作者：deqianzou<br>
                    链接：https://www.nowcoder.com/discuss/73516?type=2&amp;order=3&amp;pos=477&amp;page=1<br>
                    来源：牛客网</p>
                <p>（上来先问了项目的东西，略。）</p>
                <ol>
                    <li>ArrayList中删除值为a的元素怎么操作<br>
                        list.remove(a);</li>
                    <li>使用Iterator遍历HashMap，删除值为a的元素会发生什么<br>
                        currentmodfiyexception。也就是拒绝操作，禁止在迭代阶段修改数据，否则会抛出异常，</li>
                </ol>
                <p>如果modCount不等于expectedModCount，则抛出ConcurrentModificationException异常。<br>
                    　　很显然，此时modCount为1，而expectedModCount为0，因此程序就抛出了ConcurrentModificationException异常。<br>
                    3. 介绍一下HashMap</p>
                <ol start="4">
                    <li>
                        <p>既然提到红黑树，就说说红黑树</p>
                    </li>
                    <li>
                        <p>介绍一下Java的gc<br>
                            分代gc，gc算法，gc回收器，jvm调优。</p>
                    </li>
                    <li>
                        <p>什么情况下会出发重量级的全局的gc，如何调优避免<br>
                            【分析】<br>
                            1.minor gc很频繁，但时间短所以问题不大，触发原因基本都是申请空间失败。</p>
                    </li>
                </ol>
                <p>2.偶尔有System.gc()，时间大概1分钟。代码中没有显式调用，基本确定是监控程序RMI访问触发的。可以加参数禁用 -XX:+DisableExplicitGC 。</p>
                <p>3.时常有promotion failed，即在minor gc时年轻代的存活区空间不足而进入老年代，老年代又空间不足而触发full
                    gc。时间大概3分钟。解决思路一种是增大存活区，一种则相反是去掉存活区增大老年代。相关参数一般有：<br>
                    -XX:SurvivorRatio=32 存活区除以伊甸区的比率，存活区有from和to两个，所以这里的意思是单个存活区占年轻代的1/34；<br>
                    -XX:OldSize=60M 老年代大小；<br>
                    -XX:MaxTenuringThreshold=15 即多少次minor gc后存活的年轻代对象会晋升老年代。</p>
                <p>4.经常有concurrent mode failure，即CMS执行过程中老年代空间不足，这时会变成Serial
                    Old收集器导致更长时间的停顿。时间大概5分钟。其中引发这一问题的情况可能是浮动垃圾太多、可能是CMS收集器本身也占用堆空间、也可能是老年代太多碎片，但都是CMS收集器的特性导致的。相关配置一般有：<br>
                    -XX:CMSInitiatingOccupancyFraction=80 即老年代满80%时触发CMS(full gc)，调高则full gc相对减少，调低则full gc处理得比较快；<br>
                    -XX:UseCMSCompactAtFullCollection 或 -XX:CMSFullGCsBeforeCompaction=5 即full gc前或后做碎片整理。<br>
                    7. 如何查看gc的情况</p>
                <p>详细的 GC 日志<br>
                    借助 Linux 平台下的 iostat、vmstat、netstat、mpstat 等命令监控系统情况<br>
                    使用 GCHisto 这个 GC 图形用户界面工具，可以统计出 Minor GC 及 Full GC
                    频率及时长分布，可参考:http://blog.csdn.net/wenniuwuren/article/details/50760259<br>
                    查看 GC 日志中是否出现了上述的典型内存异常问题（promotion failed, concurrent mode
                    failure），整体来说把上述两个典型内存异常情况控制在可接受的发生频率即可，对 CMS 碎片问题来说杜绝以上问题似乎不太可能，只能靠 G1 来解决了<br>
                    是不是 JVM 本身的 bug 导致的<br>
                    如果程序没问题，参数调了几次还是不能解决，可能说明流量太大，需要加机器把压力分散到更</p>
                <ol start="8">
                    <li>算法题，给定正整数n和x，求1到n中x出现的次数，比如1到12中2出现了两次，分别是2，12中各一次。</li>
                </ol>
                <p>关于项目，面试官不满意，他以为我了解过open stack云中的neutron模块</p>
                <p>关于Java，1只回答了使用remove方法，第2题没明白在问什么，第4题说不会，第6题不会，第7题不会，</p>
                <p>算法题，只大致说了思路，从最高位开始递归，但是我一开始讲的太乱了，对方听不下去了最后让我举个例子1024中2的次数该怎么算</p>
                <p>最后我问面试官他们的工作是什么，他说做的东西和open stack的neutron功能差不多。</p>
                <p>作者：StormWangxhu<br>
                    链接：https://www.nowcoder.com/discuss/73191?type=2&amp;order=3&amp;pos=494&amp;page=1<br>
                    来源：牛客网</p>
                <p>前言<br>
                    炎热的下午，刚在体育课上测完了一千米，嗓子要着火了，跑完后感觉要膨胀了，又测了50、身高、肺活量、体前屈。测完后就在树荫下休息，离下课还有10分钟的时候，口袋里的手机突然想起，拿起一看，阿里巴巴集团，当时就意识到可能是要和我商量面试时间，但接了后，却和其他公司不一样，面试官直接就问我，有时间吗？我们简单面试一下。我看了看体育老师，过去请了个假，就赶紧去一边面试了，不知道为什么声音很小，我有点儿听不清，好几次就请求面试官：“不好意思呢，刚才没听清，嘻嘻~”挺尴尬的。面试了34分钟。我到现在有的问题都忘了，大体内容如下：面试内容<br>
                    1、自我介绍：balabala</p>
                <p>2、现在都学习了些什么？balabala</p>
                <p>3、HashMap底层实现原理，是否读过HashMap源码？</p>
                <p>4、HashMap和ConcurrentHashMap在线程安全上有何区别？如何实现？</p>
                <p>5、项目：小程序。问到遇到什么问题吗？在这里问了好多，还有业务逻辑，感觉答得都不是太好。</p>
                <p>6、了解过哪些中间件？</p>
                <p>7、Java 的特性？</p>
                <p>8、Java 内存模型</p>
                <p>9、JVM 类加载机制</p>
                <p>10、双亲委派模型</p>
                <p>11、Object都有哪些方法？<br>
                    equals，hashcode，clone，<br>
                    wait，notify,notifyall。<br>
                    getclass()，由于方法维护这一个Class对像，通过该方法可以获得该对象，并且使用反射机制获取它的各种信息<br>
                    ,finalize，该方法应该是在对象被回收前会调用的收尾工作方法。</p>
                <p>12、高并发、高并发、高并发！重要的说三遍。如何解决？答得不太好，一脸懵逼！<br>
                    高并发。解决方式：<br>
                    1 前端负载均衡，如果是web，可以前后端分离，cdn处理静态资源。<br>
                    2 ngnix7层负载均衡，转发到多个应用服务器。<br>
                    3 在数据库之前加上缓存。<br>
                    4 数据库读写分离。主从部署。<br>
                    5 如果有秒杀场景，再通过消息队列对请求进行削峰再到达缓存层。<br>
                    6 机器配置提升，代码优化，使用并发编程，使用异步IO或者多路复用</p>
                <p>13、锁优化CAS<br>
                    cas实现轻量级锁和偏向锁，不需要synchronized底层使用mutex lock切换上下文。</p>
                <p>14、sychronized和volitile</p>
                <p>重量级锁。<br>
                    内存屏障实现volatile变量的读写语义。</p>
                <p>15、还问了我的英语怎么样？考六级了吗</p>
                <p>16、在Github上关注了什么开源项目了没？</p>
                <p>17、看了我的博客（挺开心的，感觉博客搭建上还是挺好的），问我是自学吗？一般怎么学？</p>
                <p>18、了解Linux吗？确实没咋用，就说了知道几个命令。</p>
                <p>19、觉得自己是一个怎样的人？</p>
                <p>大概就这些吧，有些记不起来了，最后也没像头条面试官一样，问我有什么问题要问吗？就说那就今天先面试到这儿，我说了声谢谢。哦，对了，开头自我介绍前，还问我什么时候可以来实习，能实习多长时间？然后就没了，大厂面试就这样结束了。不知道结果会怎么样，以我现在的知识，估计也去不了，还得继续加油努力呢！路漫漫其修远兮，吾将上下而求索！<br>
                    博客：https://stormwangxhu.github.io</p>
                <p>作者：如何进阿里<br>
                    链接：https://www.nowcoder.com/discuss/72899?type=2&amp;order=3&amp;pos=509&amp;page=1<br>
                    来源：牛客网</p>
                <p>十分幸运 拿到阿里云的offer，感谢周围无数人对我的支持和鼓励，所以写篇面经希望可以帮助大家。<br>
                    面试中，运气占很大一部分的，所以你们若是没有通过，一定不要气馁，继续加油。<br>
                    每个努力的人 都值得钦佩，无论结果如何。</p>
                <p>我说点面试中的小技巧，可以帮助你更好发挥，（注意，这个方法比较适合我，不一定适合你哇）<br>
                    完全可以将学到的知识讲给自己（或者讲给别人），若是自己（别人）听你的讲述 能够听懂（使用自己的话去讲，而不要有专业术语），那么说明 你已经学好了。其原理就是 费曼学习法。感兴趣的人可以去了解下。
                </p>
                <p>我个人习惯于 将一个知识点 分解为 xxx是什么，xxx有什么用，如何实现这个功能的（核心的工作流程），缺点是什么（以及为什么有这个缺点，缺点如何补救）。</p>
                <p>举个例子， CMS垃圾回收器回收时为什么有内存碎片 ， 首先分解为CMS是什么，内存碎片是什么？</p>
                <p>CMS垃圾回收器有什么用和Serial ParNew Parallel 等比较，优势，CMS是如何工作的，来实现尽可能降低响应时间的，为什么CMS有这个缺点，它是如何取舍的，如何补救这个缺点。</p>
                <p>这些子问题都回答好，那么基本上这个问题就学的可以了。</p>
                <p>这样可以检测你是否学好，而且，若是你都没法条理清晰地讲给自己，那怎么条理清晰地讲给面试官呢？</p>
                <p>接下来就写下三次面试题目：<br>
                    阿里一面：</p>
                <p>1.个人介绍</p>
                <p>2.项目介绍，项目介绍首先讲最好的项目，因为后面的项目可能都没时间去讲。</p>
                <p>3.数据库 联合索引 用法</p>
                <p>4.Spring IOC初始化过程<br>
                    1首先实例化一个上下文比如applicationxmlcontext，就会去读取xml文件的bean。<br>
                    2然后解析xml的bean，定义成beandefinition数据结构，注册到内部的一个listablebeanfactory中，该工厂负责beandefinition的保存。<br>
                    3接着根据默认规则进行单例实例化，实例化之前可能会包装动态代理，或者进行属性配置，前置后置方法的调用等。（拦截器）。<br>
                    4 然后就可以通过getbean的方式获取这些类的单例了。</p>
                <p>5.ConcurrentHashMap实现原理</p>
                <p>6.CAS操作<br>
                    硬件支持，aba<br>
                    7.ReentrantLock和Synchronized区别<br>
                    aqs<br>
                    watcher+monitor，底层是mutex lock</p>
                <p>8.CMS垃圾回收过程<br>
                    1初始标记gcroot<br>
                    2 停顿并且并发标记。<br>
                    3 更新标记<br>
                    4 并发清除</p>
                <p>9.Full GC次数太多了，如何优化。<br>
                    说明可能有promotion问题和老年代空间不足的问题。、</p>
                <p>可以减小存活区，提高阈值，增大老年代等。<br>
                    10.直接内存 如何 管理的<br>
                    直接内存是堆外内存，通过堆内的引用来连接，回收引用时也会通过追踪算法去回收直接内存。<br>
                    直接内存不受到jvm管理，所以适合用作缓冲区。<br>
                    11.线程池 参数。</p>
                <p>线程创建的过程。有几种方法<br>
                    。<br>
                    线程资源如何回收的。<br>
                    工作线程回收需要满足三个条件：</p>
                <ol>
                    <li>参数allowCoreThreadTimeOut为true</li>
                    <li>该线程在keepAliveTime时间内获取不到任务，即空闲这么长时间</li>
                    <li>当前线程池大小 &gt; 核心线程池大小corePoolSize。</li>
                </ol>
                <p>一个题目：如何将一个二叉树，转为有序的双向链表。</p>
                <p>阿里二面<br>
                    1.自我介绍<br>
                    2.项目介绍<br>
                    3.堆和栈介绍</p>
                <p>4.线程安全</p>
                <p>5.乐观锁悲观锁</p>
                <p>6.TCP三次握手</p>
                <p>7.socket通信有关，select epoll</p>
                <p>8.项目中的难点有哪些</p>
                <p>我答得是：使用一个组合的设计模式 去解决文章多级分类的问题。</p>
                <p>交叉面<br>
                    1.自我介绍<br>
                    2.项目介绍</p>
                <p>3.做这个项目的动机</p>
                <p>4.TCP UDP IP ICMP<br>
                    icmp负责ip地址的探测，以及路由信息的获取。<br>
                    ping和traceroute分别用于探索ip是否可达，和路由信息跟踪。<br>
                    5.知不知道一个应用层协议，运输层既没有使用TCP，也没有使用UDP</p>
                <p>6.二叉树中求最长路径。</p>
                <p>递归的方式去实现。</p>
                <p>先求左子树深度，后求右子树深度。相加减一，那么就是以当前结点为转折点的解。</p>
                <p>然后递归求左子树的解，和右子树的解。返回当前解，左子树解，右子树解中最大的解。时间复杂度为O(n*logn)</p>
                <p>其实可以优化到O(n) ，其实不必求两个子树的解，只需要求较深子树的解即可。</p>
                <p>7.有什么想问我的吗？<br>
                    //您觉得成为一个顶尖高手，最重要的是什么呢？</p>
                <p>兴趣。做自己感兴趣的事，就不会很疲惫，也会很开心。 //这一点我深有同感。</p>
                <p>抓住你的兴趣，做你想做的事，自己驱动自己进步。</p>
                <p>//很感谢您的建议。</p>
                <p>hr面试<br>
                    1.自我介绍。<br>
                    2.项目介绍。项目中难点。得过啥奖没。<br>
                    3.项目有什么不足？<br>
                    4.前面的面试 发挥怎么样？<br>
                    5.前面的面试难度怎样？</p>
                <p>愿大家都能拿到自己理想的offer。</p>
                <p>作者：Flexable<br>
                    链接：https://www.nowcoder.com/discuss/72609?type=2&amp;order=3&amp;pos=533&amp;page=1<br>
                    来源：牛客网</p>
                <p>主要是因为我得一面主要还是问的项目问题，所以一二面整理在一起问<br>
                    —————————华丽的分割线——————————————————<br>
                    一面：面了多久忘了<br>
                    问题一：请说一下你自己的印象最深的一个项目<br>
                    问题二：问了下项目相关的一些想法<br>
                    —————————华丽的分割线——————————————————<br>
                    二面：28分钟多一点<br>
                    问题一：请简单做一下自我介绍<br>
                    问题二：我看你写的你熟悉面向对象编程，你说下你熟悉的几种设计模式吧<br>
                    简单工厂，工厂，代理模式，观察者，装饰者，单例<br>
                    问题三：你说一下servlet如何保证单例的线程安全的</p>
                <p>1、Servlet如何处理多个请求访问？<br>
                    答：Servlet容器默认是采用单实例多线程的方式处理多个请求的：<br>
                    1.当web服务器启动的时候（或客户端发送请求到服务器时），Servlet就被加载并实例化(只存在一个Servlet实例)；<br>
                    2.容器初始化化Servlet主要就是读取配置文件（例如tomcat,可以通过servlet.xml的设置线程池中线程数目，初始化线程池通过web.xml,初始 化每个参数值等等。<br>
                    3.当请求到达时，Servlet容器通过调度线程(Dispatchaer Thread) 调度它管理下线程池中等待执行的线程（Worker Thread）给请求者；<br>
                    4.线程执行Servlet的service方法；<br>
                    5.请求结束，放回线程池，等待被调用；<br>
                    （注意：避免使用实例变量（成员变量），因为如果存在成员变量，可能发生多线程同时访问该资源时，都来操作它，照成数据的不一致，因此产生线程安全问题）</p>
                <p>问题四：说一下在学习java虚拟机的时候，你认为最难理解的是什么</p>
                <p>class字节码的组织结构以及解析过程。</p>
                <p>问题五：你怎么解决这些难以理解的点的？</p>
                <p>看了一些博客，发现它有独特的解析规则以及语法分析，语义分析等方法。</p>
                <p>问题六：JVM的内存划分和每一块的功能</p>
                <p>问题七：说一下栈的内存是怎么分配的<br>
                    栈内存包括栈帧，线程私有的。</p>
                <p>一： Java 堆内存空间<br>
                    Java程序运行时使用java Heap 内存为对象以及JRE类分配内存, 不论我们在何时创建何种类型的对象, 他总是在堆内存中创建的<br>
                    Java 垃圾收集器运行在堆内容空间, 释放那些没有任何引用的对象所使用的内存。 在堆内存空间创建的任何对象都具有全局访问权限, 并且可以从程序的任何位置引用<br>
                    二： Java 栈内存空间<br>
                    Java 栈内存空间用于执行线程, 栈内存始终遵循LIFO(Last-in-first-out) 顺序, 每当一个方法被执行, 会在栈内存中创建一个新的block
                    用于保存在函数中定义的基本数据类型变量以及对象的引用变量<br>
                    当方法结束时, this block 改变它的状态为未使用并且可用于执行下一个方法<br>
                    栈内存大小与堆内存相比非常少。</p>
                <p>1, 堆内存属于java 应用程序所使用, 栈内存属于线程所私有的, 它的生命周期与线程相同<br>
                    2, 不论何时创建一个对象, 它总是存储在堆内存空间 并且栈内存空间包含对它的引用 . 栈内存空间只包含方法原始数据类型局部变量以及堆空间中对象的引用变量<br>
                    3, 在堆中的对象可以全局访问， 栈内存空间属于线程所私有<br>
                    问题八：说一下栈帧的内存是怎么分配的<br>
                    栈帧（Stack Frame）是用于支持虚拟机进行方法调用和方法执行的数据结构，它是虚拟机运行时数据区中的虚拟机栈（Virtual Machine Stack）的栈元素。</p>
                <h2><a name="t0"></a><a
                        id="&#10;HTTP10HTTP11&#10;_421"></a>栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。每一个方法从调用开始到执行完成的过程，就对应着一个栈帧在虚拟机里面从入栈到出栈的过程。<br>
                    问题九：HTTP1.0和HTTP1.1的区别<br>
                    长连接</h2>
                <h2><a name="t1"></a><a id="HTTP_10keepaliveHTTP11&#10;HTTPTCPIPTCP&#10;_425"></a>HTTP
                    1.0需要使用keep-alive参数来告知服务器端要建立一个长连接，而HTTP1.1默认支持长连接。<br>
                    HTTP是基于TCP/IP协议的，创建一个TCP连接是需要经过三次握手的,有一定的开销，如果每次通讯都要重新建立连接的话，对性能有影响。因此最好能维持一个长连接，可以用个长连接来发多个请求。<br>
                    节约带宽</h2>
                <p>HTTP 1.1支持只发送header信息(不带任何body信息)，如果服务器认为客户端有权限请求服务器，则返回100，否则返回401。客户端如果接受到100，才开始把请求body发送到服务器。<br>
                    这样当服务器返回401的时候，客户端就可以不用发送请求body了，节约了带宽。<br>
                    另外HTTP还支持传送内容的一部分。这样当客户端已经有一部分的资源后，只需要跟服务器请求另外的部分资源即可。这是支持文件断点续传的基础。<br>
                    问题十：hashmap和hashtable的区别</p>
                <p>问题十一：之后就是谈谈一些家庭情况<br>
                    ————————华丽的分割线————————————————————<br>
                    总之阿里的面试还是很偏重于基础和底层的一些东西</p>
                <p>作者：努力努力再努力呀<br>
                    链接：https://www.nowcoder.com/discuss/72122?type=2&amp;order=3&amp;pos=567&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里</p>
                <ul>
                    <li>
                        <p>一面</p>
                    </li>
                    <li>
                        <p>自我介绍</p>
                    </li>
                    <li>
                        <p>校园经历，成绩，怎么学习新知识，未来的学习规划</p>
                    </li>
                    <li>
                        <p>项目为什么用redis，redis集群</p>
                    </li>
                    <li>
                        <p>了解的集合类，hashset原理，arraylist和linkedlist的区别，性质</p>
                    </li>
                    <li>
                        <p>多线程项目用没用过，线程的调度，函数的具体含义</p>
                    </li>
                    <li>
                        <p>数据库水平切分，垂直切分</p>
                    </li>
                    <li>
                        <p>数据库优化</p>
                    </li>
                    <li>
                        <p>两个字符串数组，比较是否相等，忽略顺序</p>
                    </li>
                    <li>
                        <p>你有什么想问我的</p>
                    </li>
                </ul>
                <p>阿里一面面试官评价基础还行，工程还得加强，挂</p>
                <p>作者：Marshall23<br>
                    链接：https://www.nowcoder.com/discuss/72086?type=2&amp;order=3&amp;pos=573&amp;page=1<br>
                    来源：牛客网</p>
                <p>报的java后台，3月中旬简历面，昨天现场一面，今天查到被拒了。<br>
                    1自我介绍<br>
                    2擅长什么（jvm,数据结构，并发，算法，数据库）</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">     3说说并发，里面包括些什么
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>1AQS是并发包的基础，提供了一些方法的实现，比如state，lock和unlock的方法，还提供了阻塞线程使用的clh阻塞队列。</p>
                <p>2Lock通过AQS实现锁，内部有两个实现类fairsync和unfairsync继承AQS的Sync抽象类。condition则自己实现阻塞队列，和lock配合使用。</p>
                <p>3原子类使用cas操作完成原子操作，保证线程安全。底层基于unsafe包的cas方法实现，而cas方法又是由硬件提供的功能。</p>
                <p>4阻塞队列分为很多种结构，比如数组，链表。无界队列等，可以通过其实现经典的生产者消费者模型。</p>
                <p>5线程池则是通过对阻塞队列，线程组，任务进行封装，实现了一个可以复用线程的线程池，其中也分很多种。</p>
                <p>并且线程池一般都有一些常用参数，比如阻塞队列，核心线程数，最大线程数，拒绝策略，超时时间等。</p>
                <p>6并发容器如chm和copyonwritelist，跳表，保证读取的线程安全，并且在写时通过同步操作或者复制的方式保证并发安全。</p>
                <p>7并发工具类：countdownlatch和samphere基于AQS的共享锁实现，cliderbarrier基于lock和condition实现。还有exchanger。</p>
                <p>8辅助类，locksupport，专门用来阻塞线程等功能。<br>
                    4说下ConcurrentHashMap 你知道些什么？怎么设计的？为什么不同的key会放在相同的位置？</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">     5volatile有什么用？可见性怎么实现的？
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>volatile保证原子性和可见性。<br>
                    原子性是保证单个变量的读写是原子性的，不会出现double被切割的情况。<br>
                    可见性是通过内存屏障来实现读写语义的，遇到读内存屏障直接从主内存读取，遇到写内存屏障直接写入主存。<br>
                    6讲讲知道的数据结构（ArrayList,LinkinedList,HashMap,HashSet,Stack）</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">     7jvm相关，我一顿讲（二、三章内容）

     8一篇英文文献，怎么找出出现次数最多的单词
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li></ul></pre>
                <p>MapReduce。<br>
                    hash表。<br>
                    9有什么想问我的<br>
                    总结：问题基本上都答上来了，可是面试官觉得我的理解不够深入，可能这就是我现在存在的最大的问题吧。分享给大家攒一波人品，希望各位都能拿到满意的Offer</p>
                <p>作者：﹏*安分<br>
                    链接：https://www.nowcoder.com/discuss/72011?type=2&amp;order=3&amp;pos=575&amp;page=1<br>
                    来源：牛客网</p>
                <p>介绍项目，<br>
                    线程，进程的区别，线程的调度方式，线程和进程间通信，线程的状态，</p>
                <p>四、线程的调度<br>
                    线程的调度，取决于支持的是内核级线程还是用户级线程。</p>
                <p>对于用户级线程，内核不知道线程的存在，就给了进程很大的自主权。内核只是调度进程，进程中的调度程序选择哪个线程来运行。</p>
                <p>对于内核级线程，线程的调度就交给了系统完成。<br>
                    五、Linux中的进程与线程调度<br>
                    首先明确一个概念，Linux系统中甚至没有真正的线程。不过，可以认为Linux是系统的线程是内核线程，所以调度是基于线程的。<br>
                    一个进程由于其运行空间的不同, 从而有内核线程和用户进程的区分, 内核线程运行在内核空间, 之所以称之为线程是因为它没有虚拟地址空间, 只能访问内核的代码和数据, 而用户进程则运行在用户空间,
                    但是可以通过中断, 系统调用等方式从用户态陷入内核态。<br>
                    用户进程运行在用户空间上, 而一些通过共享资源实现的一组进程我们称之为线程组, Linux下内核其实本质上没有线程的概念,
                    Linux下线程其实上是与其他进程共享某些资源的进程而已。但是我们习惯上还是称他们为线程或者轻量级进程。<br>
                    因此, Linux上进程分3种，内核线程（或者叫核心进程）、用户进程、用户线程, 当然如果更严谨的，也可以认为用户进程和用户线程都是用户进程。<br>
                    Linux中，进程和线程都被维护为一个task_struct结构，线程和进程被同等对待来进行调度。<br>
                    Linux将线程区分为3类：<br>
                    （1）实时先入先出。<br>
                    （2）实时轮转。<br>
                    （3）分时。</p>
                <p>hashmap的扩容，put方法，实现，基本都问了，hashtable，concurrenthashmap。<br>
                    略<br>
                    arraylist，linkedlist都问实现，区别，list中还有哪些是线程安全的。<br>
                    略<br>
                    我说到hashmap1.8实现，链表长度大于等于8就转红黑树。然后，果不其然，问我红黑树，不会?<br>
                    略</p>
                <p>spring的aop和ioc，有哪些设计模式，叙述单例模式，我叙述完他问我单例是不是线程安全的，我说不是，就问他是不是要问我 double-check，他说是，我<br>
                    两个都笑了，我说我不会，然后让我说责任链模式。<br>
                    1 饱汉<br>
                    2 饿汉<br>
                    3 同步<br>
                    4 双重检查<br>
                    5 静态内部类<br>
                    6 枚举类</p>
                <p>synchronized锁解释，还有它的膨胀机制。<br>
                    偏向锁，轻量级锁，重量级锁</p>
                <p>线程的状态都有啥？还有wait方法，</p>
                <p>火车票抢票，只有一台服务器，瞬时访问量很大，如何系统的解决？<br>
                    前端页面限制，url屏蔽，缓存 ，消息队列，负载均衡。</p>
                <p>问我你看哪些书？我说并发编程实战，编程珠玑，然后问我并发编程实战的作者是谁？这些书你都买下看过没？<br>
                    doug lea Java并发编程之父</p>
                <p>问我区块链知道不？说一下，</p>
                <p>问我最近有哪些新技术？我说java10发布了，他说你先别管java10，说一下java8都更新了什么？我说知道lambda表达式，我说还对hashmap做出了优化，他问还有啥？我说好像还有函数式编程，他说函数式编程不就是lambda表达式吗？
                </p>
                <p>1 lambda和函数式编程<br>
                    2 接口的默认方法<br>
                    3 日期和事件api<br>
                    4 流式集合和api<br>
                    5 option方法。<br>
                    6 chm等集合的优化</p>
                <p>作者：SmallLime<br>
                    链接：https://www.nowcoder.com/discuss/71870?type=2&amp;order=3&amp;pos=591&amp;page=1<br>
                    来源：牛客网</p>
                <p>刚刚结束阿里Java第二轮视频面试，感觉有点像部门主管面试，大部分时间在聊天，讨论个人经历，但是没有很着重技术方面，也没有像一面一样每个知识点深挖。时间大概聊了四十分钟左右。<br>
                    自我介绍<br>
                    针对自我介绍中谈论的点展开聊天，主要谈个人见解<br>
                    穿插技术性问题：谈到网站开发时问Servlet，延展线程安全，多线程同步，分布式问题</p>
                <p>OOP理解：继承vs组合</p>
                <p>英文交流：自己找话题，以及看过那些书，非专业的书</p>
                <p>觉得这次面试主要是考察思想和理解，比如在过去的某个经历中，是否真的学到了或者理解了什么。还有面试官有提到passion，觉得也可能想考察是否适合这个团队。</p>
                <p>觉得视频面试需要注意的就是，要微笑，要显示出自己很有热情，即使是聊天，一定要说一些体现自己的经历、理解和思想的问题，要说一些面试官可能感兴趣的事情，比如在英文聊天的过程中，因为面试的是B2B团队，我就说了上学期针对一个美国CRM公司做的调研，然后进行展开。关于技术问题也是主要考验是否深入理解，中间即使遇到不太熟练的问题也要表现的很虚心认真，边听边记下来。
                </p>
                <p>总之觉得，能遇到这种比较重视思想和理解以及软实力的面试官，可以说是很幸运了，可以在聊天的过程中了解到个人学习和理解能力，个人积累，以及个人态度，还是很重要的。<br>
                    收藏(10)</p>
                <p>作者：我要进阿里<br>
                    链接：https://www.nowcoder.com/discuss/71615?type=2&amp;order=3&amp;pos=610&amp;page=2<br>
                    来源：牛客网</p>
                <p>整个三月份通过牛客网和网友分享的经验学到了很多东西，现在反馈一下我的面试经历，希望对同学们有帮助。<br>
                    个人情况：大三本EE方向渣硕，经过实验室学长内推，于三月底完成面试。岗位是Java研发。<br>
                    面经如下：<br>
                    一面：<br>
                    自我介绍</p>
                <p>简述TCP三次握手、四次挥手</p>
                <p>TIME_WAIT为什么要等待2MSL，TIME_WAIT是客户端状态还是服务端状态</p>
                <p>1防止server没有收到最后一个ack，则会重发fin请求<br>
                    2让本次连接中的请求都过期。</p>
                <p>TCP和UDP的区别，你的手机上有哪些App会采用UDP<br>
                    qq。udp发送信息不需要建立连接，所以有时候会发送失败<br>
                    直播也可以使用udp，否则重发机制和有序要求不适合直播，允许出现小丢包</p>
                <p>TCP/UDP应用场景：<br>
                    基于上面的优缺点，那么：<br>
                    什么时候应该使用TCP：<br>
                    当对网络通讯质量有要求的时候，比如：整个数据要准确无误的传递给对方，这往往用于一些要求可靠的应用，比如HTTP、HTTPS、FTP等传输文件的协议，POP、SMTP等邮件传输的协议。<br>
                    在日常生活中，常见使用TCP协议的应用如下：<br>
                    浏览器，用的HTTP<br>
                    FlashFXP，用的FTP<br>
                    Outlook，用的POP、SMTP<br>
                    Putty，用的Telnet、SSH<br>
                    QQ文件传输<br>
                    …………<br>
                    那么什么时候应该使用UDP：<br>
                    当对网络通讯质量要求不高的时候，要求网络通讯速度能尽量的快，这时就可以使用UDP。<br>
                    比如，日常生活中，常见使用UDP协议的应用如下：<br>
                    QQ语音<br>
                    QQ视频<br>
                    TFTP<br>
                    ……<br>
                    TCP滑动窗口<br>
                    滑动窗口可以控制发送每次发送数据包的数量，并且确认一个包以后就可以发下一个包，相当于可以连续发送然后连续确认，效率较高。<br>
                    流控窗口可以使用流量控制机制来限制发送流量和接受流量。<br>
                    HTTP状态码<br>
                    100客户端可以继续发送请求，一般用于http1.1的两次发送，第一次发header，第二次发body。<br>
                    200 请求成功<br>
                    301永久重定向，之后发的请求都会转发到新的uri上<br>
                    302临时重定向，本次请求会被转发到新的uri上。<br>
                    400 Bad Request<br>
                    1、语义有误，当前请求无法被服务器理解。除非进行修改，否则客户端不应该重复提交这个请求。<br>
                    2、请求参数有误。<br>
                    403 Forbidden<br>
                    服务器已经理解请求，但是拒绝执行它。<br>
                    404 Not Found<br>
                    请求失败，请求所希望得到的资源未被在服务器上发现。404这个状态码被广泛应用于当服务器不想揭示到底为何请求被拒绝或者没有其他适合的响应可用的情况下。出现这个错误的最有可能的原因是服务器端没有这个页面。<br>
                    你所了解的排序算法，简述快速排序的思路以及在最好的情况下和最坏情况下的时间复杂度<br>
                    插入排序，选择排序，冒泡排序：复杂度都是O（n2）<br>
                    堆排序，快排，归并排序是Ologn。<br>
                    快排在序列有序时复杂度O（n2)是最差的情况。<br>
                    归并和堆排序的复杂度都稳定在O（nlogn）<br>
                    但需要知道的是，不稳定的排序算法有：快排，希尔排序，选择排序，堆排序。</p>
                <p>B树和B+树的区别<br>
                    B树的定义<br>
                    这里的B树，也就是英文中的B-Tree，一个 m 阶的B树满足以下条件：<br>
                    每个结点至多拥有m棵子树；<br>
                    根结点至少拥有两颗子树（存在子树的情况下）；<br>
                    除了根结点以外，其余每个分支结点至少拥有 m/2 棵子树；<br>
                    所有的叶结点都在同一层上；<br>
                    有 k 棵子树的分支结点则存在 k-1 个关键码，关键码按照递增次序进行排列；<br>
                    关键字数量需要满足ceil(m/2)-1 &lt;= n &lt;= m-1；<br>
                    B+树<br>
                    同样的，以一个m阶树为例：<br>
                    根结点只有一个，分支数量范围为[2，m]；<br>
                    分支结点，每个结点包含分支数范围为[ceil(m/2), m]；<br>
                    分支结点的关键字数量等于其子分支的数量减一，关键字的数量范围为[ceil(m/2)-1, m-1]，关键字顺序递增；<br>
                    所有叶子结点都在同一层；<br>
                    二叉树和平衡二叉树的区别<br>
                    平衡树对左右节点有要求。<br>
                    什么是线程安全<br>
                    如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。<br>
                    怎么创建一个线程，继承Thread类和实现Runnable接口的比较<br>
                    实现Runnable接口和继承Thread类区别<br>
                    如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。<br>
                    实现Runnable接口比继承Thread类所具有的优势：<br>
                    1）：适合多个相同的程序代码的线程去处理同一个资源<br>
                    2）：可以避免java中的单继承的限制<br>
                    3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立<br>
                    重载和重写的区别</p>
                <p>HashMap是线程安全的吗，有哪些线程安全的容器，HashMap底层用什么数据结构实现的，put方法是怎么实现的，怎么解决哈希冲突，怎么扩容</p>
                <p>介绍一下ConcurrentHashMap,get方法是怎么定位到某个具体的位置（JDK1.7环境下）<br>
                    hash值，然后和表长相与，然后定位到数组索引，接着搜索链表或者红黑树<br>
                    介绍一下CopyOnWriteArrayList的应用场景以及实现原理<br>
                    读多写少的场景<br>
                    单例模式的实现代码，以及该模式主要应用在哪些场景<br>
                    1任务管理器就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？<br>
                    2（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。<br>
                    3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。<br>
                    4.
                    数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。<br>
                    5. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。<br>
                    Jvm内存溢出的种类<br>
                    栈内存，堆内存，方法区<br>
                    数据库有了解过吗，自己在下面安装的过什么数据库，Mysql?Oracle?</p>
                <p>mysql<br>
                    有什么需要问的</p>
                <p>二面：<br>
                    撸代码，最大子数组求和问题<br>
                    最大子数组的和。用dp可以解<br>
                    偏智力题，小白鼠验毒药问题<br>
                    一只小白鼠表示0或1,10只小白鼠可以组成10位的二进制数，2的10进制是1024。<br>
                    比如0000000001表示第一瓶酒，0000000010表示第二瓶酒，当毒发时，根据之前的结果，小白鼠可以排成一个数，中毒的时候，排成的这个数就是有毒的酒<br>
                    介绍一下Jvm的内存模型，有哪些是线程安全的<br>
                    线程私有的栈是线程安全的，本地方法栈是共有的，非线程安全的。<br>
                    Jvm垃圾回收算法，新生代采用什么算法，老年代采用什么算法<br>
                    略<br>
                    i++,线程A：i++,线程B：i–，在非线程安全的情况下，i有几种取值，采用什么方法使得i线程安全<br>
                    1同步<br>
                    2volatile<br>
                    数组和链表的比较</p>
                <p>HashMap是如何解决哈希冲突的</p>
                <p>介绍一下你实习做的项目，这个项目是几个人做的，遇到了什么困难，你是怎么解决的，完成这个项目用了多长时间</p>
                <p>HR面：<br>
                    你是怎么知道这个部门的，你对这个部门有哪些了解</p>
                <p>你还投了哪些公司的招聘，你同学还投了哪些公司，如果很多家公司给你offer，你会选择哪一家</p>
                <p>你希望留在哪个城市，为什么</p>
                <p>你在学校做过什么项目，你实习的项目和学校做过的项目对该职位有什么帮助</p>
                <p>有什么需要问的</p>
                <p>总结：<br>
                    春招实习之路真的是很艰辛，自己本来也不是CS方向的，很多基础课和本专业的同学差距真的太多，但是只要足够努力，必定会得到一个满意的结果，路漫漫其修远兮，吾将上下而求索。大家加油！</p>
                <p>作者：SmallLime<br>
                    链接：https://www.nowcoder.com/discuss/71383?type=2&amp;order=3&amp;pos=632&amp;page=1<br>
                    来源：牛客网</p>
                <p>3.15 电话一面 Java研发：<br>
                    自我介绍<br>
                    项目介绍与遇到的难点<br>
                    ArrayList vs LinkedList<br>
                    HashMap原理<br>
                    JDK 1.8对HashMap的改进<br>
                    多线程见协作与通信方式<br>
                    　系统要实现某个全局功能必定要需要各个子模块之间的协调和配合，就像一个团队要完成某项任务的时候需要团队各个成员之间密切配合一样。而对于系统中的各个子线程来说，如果要完成一个系统功能，同样需要各个线程的配合，这样就少不了线程之间的通信与协作。常见的线程之间通信方式有如下几种：<br>
                    　　1、wait和notify/notifyAll<br>
                    　　 2、await和signal/signalAll<br>
                    　　3、sleep/yield/join<br>
                    　　 4、CyclicBarrier 栅栏<br>
                    　　 5、CountDownLatch 闭锁<br>
                    　　 6、Semaphore 信号量<br>
                    Synchronized vs Lock<br>
                    ReentrantLock优点<br>
                    reentrantlock的优点<br>
                    支持condition等待队列，支持公平锁，支持查看锁的状态<br>
                    可以添加多个检控条件, 如果使用synchronized,则只能使用一个. 使用 reentrant locks 可以有多个wait()/notify() 队列. [译注:直接多new
                    几个ReentrantLock就可以了,不同的场景/条件用不同的ReentrantLock ]<br>
                    可以控制线程得到锁的顺序,也就是有公平锁(按照进入顺序得到资源),也可以不按照顺就像.synchronized 一样.</p>
                <p>可以查看锁的状态, 锁是否被锁上了.</p>
                <p>可以查看当前有多少线程再等待锁.</p>
                <p>reentrantlock的缺点<br>
                    需要手动释放锁，只能在代码中上锁，不能对方法加锁<br>
                    需要使用import 引入相关的Class<br>
                    不能忘记在finally 模块释放锁,这个看起来比synchronized 丑陋<br>
                    synchronized可以放在方法的定义里面, 而reentrantlock只能放在块里面. 比较起来, synchronized可以减少嵌套</p>
                <p>CAS</p>
                <p>自旋锁<br>
                    一、自旋锁的概念<br>
                    首先是一种锁，与互斥锁相似，基本作用是用于线程（进程）之间的同步。与普通锁不同的是，一个线程A在获得普通锁后，如果再有线程B试图获取锁，那么这个线程B将会挂起（阻塞）；试想下，如果两个线程资源竞争不是特别激烈，而处理器阻塞一个线程引起的线程上下文的切换的代价高于等待资源的代价的时候（锁的已保持者保持锁时间比较短），那么线程B可以不放弃CPU时间片，而是在“原地”忙等，直到锁的持有者释放了该锁，这就是自旋锁的原理，可见自旋锁是一种非阻塞锁。<br>
                    二、自旋锁可能引起的问题：<br>
                    1.过多占据CPU时间：如果锁的当前持有者长时间不释放该锁，那么等待者将长时间的占据cpu时间片，导致CPU资源的浪费，因此可以设定一个时间，当锁持有者超过这个时间不释放锁时，等待者会放弃CPU时间片阻塞；<br>
                    2.死锁问题：试想一下，有一个线程连续两次试图获得自旋锁（比如在递归程序中），第一次这个线程获得了该锁，当第二次试图加锁的时候，检测到锁已被占用（其实是被自己占用），那么这时，线程会一直等待自己释放该锁，而不能继续执行，这样就引起了死锁。因此递归程序使用自旋锁应该遵循以下原则：递归程序决不能在持有自旋锁时调用它自己，也决不能在递归调用时试图获得相同的自旋锁。<br>
                    类加载过程</p>
                <p>内存泄漏与内存溢出，及其原因</p>
                <p>GC原理及优化策略<br>
                    1优化延迟时间<br>
                    2优化吞吐量<br>
                    3使用jstat，visualvm和gc日志分析延迟和饿饿吞吐量，然后更改配置进行调优。<br>
                    比如更换垃圾回收器，更改内存空间，设定晋升阈值等等。<br>
                    4 如果定位出是内存问题，比如oom或者内存泄漏，可以通过dump文件转储的方式，再配合mat等工具对内存进行分析。<br>
                    5
                    如果定位出是程序问题，比如代码执行错误，代码运行时间过长。cpu占用过率过高（可能死锁或并发量太大），可以通过visualvm分析线程，定位线程以后再通过jstack的方式定位代码问题。当然也可以通过日志的方式定位。<br>
                    Java的Exception类型<br>
                    runtime和非runtime异常（可检查异常）。<br>
                    runtime是数组越界这种应该避免的异常。<br>
                    检查异常是sql，io这种很难避免的异常。需要try catch</p>
                <p>数据库四种隔离级别</p>
                <p>Spring框架介绍</p>
                <p>OOP设计原则<br>
                    0开闭原则<br>
                    1里式替换<br>
                    2单一职责<br>
                    3依赖倒置<br>
                    4迪米特原则：对象对其他对象的引用越少越好。</p>
                <p>面试官人很好，面试完之后，请面试官针对我的下一步学习计划提建议，结果面试官说几次想引导我去回答更深入的问题，都没引导过去
                    [捂脸]。之后针对面试官的建议，把缺漏的知识点再整理了一遍。面试官当时说大概一周会有结果，等了一周半，以为凉了，就抱着必死的决心，向面试官问了下情况，竟然就接到了二面视频面试邀请。结果面试被拖后(鸽)了。
                </p>
                <p>想问一下各位，有经历过视频面试的同学吗？请问视频面试流程大概是什么样的呀？如果是视频的话会要求共享桌面吗？视频面试主要会考编程吗？看了一下面试官的 Title 是 Principle Software
                    Engineer应该不属于主管面把？我人不再国内，不知道这个视频面试是否相当于现场面试？求大佬们帮忙答疑解惑，感谢</p>
                <p>作者：给个offer养家糊口<br>
                    链接：https://www.nowcoder.com/discuss/71325?type=2&amp;order=3&amp;pos=641&amp;page=1<br>
                    来源：牛客网</p>
                <p>楼主南开大学大三计控弱渣一枚，只面了15分钟，妥妥的凉了。。</p>
                <p>1.自我介绍<br>
                    2.介绍自己做过的项目。<br>
                    3.聊到HashMap，问HashMap什么情况下发生死链（自己引过去的，resize的时候），实际碰到过吗<br>
                    应该说的是反生链表死循环访问。是在put过程中引起resize操作，然后在扩容时出现了新链表和旧链表的同时操作，导致新链表的指针指向自己。形成死链。<br>
                    4.Java什么时候会发生内存泄漏(静态全局变量添加了很多数据没法被GC，连接资源不释放)（PS：我和你聊GC，你就不打算和我聊聊GC吗？！）<br>
                    静态容器存储很多对象。<br>
                    连接池资源不释放，监听器等对象没有被回收。<br>
                    一些默认不释放的资源没有手动释放，比如hibernate的session，数据库连接池，lock锁，jedis池</p>
                <p>5.项目用的什么数据库，建了哪些表，有什么考虑？</p>
                <p>6.索引一定有效吗？失效的情况？索引是怎么实现的？（我就应该和面试官聊索引实现的。。）<br>
                    不一定有效。全表扫描，非前缀索引等等。<br>
                    索引使用b+树实现。innodb支持聚簇索引。</p>
                <p>7.如果你的项目数据量大100倍，1000倍的话，数据库要怎么进行改进？（分库分表，然而我就知道分库分表并不知道怎么做。。）<br>
                    百万级以内的数据可以进行单表优化，否则进行分库分表，可以按照业务纵向分表，按照数量进行横向切分，分片依据可以是id，时间戳等等，一般要是递增的，使用mycat数据库中间件可以实现分库分表，它就是一个mysql代理，可以看做是一个mysql实例，内部配置分片规则，平时直接透明操作mycat即可。<br>
                    ——————————————<br>
                    这个时代作为一枚弱渣好难找实习啊。。就想找个实习啊。。。o(╥﹏╥)o<br>
                    PS：不知道还有没有没面的兄弟。。要是有面阿里菜鸟的话，好好准备项目。。</p>
                <p>作者：牛客第0菜<br>
                    链接：https://www.nowcoder.com/discuss/71067?type=2&amp;order=3&amp;pos=666&amp;page=1<br>
                    来源：牛客网</p>
                <p>最近海投了十家公司，暂时有阿里两面（已凉）、酷家乐两面（大概凉了）、网易一面。前两个都是基础知识发挥得还可以，两家公司二面都凉凉。<br>
                    阿里一面（3.21 26min）<br>
                    刚好买了中饭回宿舍打开正准备吃的时候，我手机响了，我定睛一看0571这不是阿里的号码么，顿时就慌了，马上找耳机、拿简历出来。面试官小哥哥介绍了一下自己是阿里新零售部门的面试官，问我现在有没有时间，想和我交流交流。emmm…我说有空有空，然后就要我自我介绍一下。当时特别紧张（一是这是我人生中第一次面试多少有些慌，二是感觉自己准备得还不是特别充分，想在自己最梦想的公司的面试官前展示得更好），自我介绍的时候声音都在抖（有一两句喉咙憋住说不出话来，我说刚刚我跑上来的有点喘，小哥哥说没事没事），word天，当时脑子里就想着凉凉了凉凉了。面试官哥哥肯定感觉到了我的紧张，没有直接进入正题，而是问了我在学校都学了哪些课程，聊了会儿天。慢慢我就不紧张了，虽然后面问题感觉回答得不是很好，应该拓展地解释一下的，但还是很感谢面试官小哥哥呀，真是太贴心了~<br>
                    自我介绍</p>
                <p>学了哪些课程？开源项目了解过哪些？</p>
                <p>进程和线程的区别</p>
                <p>什么时候发生死锁？如何解决？（死锁产生的四大条件，通过破坏四个必要条件之一，如调整加锁顺序、设定加锁时限超时放弃、死锁检测、死锁避免的银行家算法可解决死锁问题）</p>
                <p>可重入锁为什么不会导致死锁？（因为上一个问题我回答了不可重入锁会导致死锁，面试官接着就问了可重入锁的原理，我就说了一下第一次加锁就获取该对象的Monitor，当Monitor计数器不为0时，只有获得锁的线程才能再次获得锁，并且每次加锁Monitor计数器就会加一解锁就会减一，当计数为零就释放对象的锁了）
                </p>
                <p>项目相关：内存数据库里存了哪些东西？心跳检测和断线重连是怎么实现的？<br>
                    netty使用idlehandler作为心跳检测处理器，间隔发送ping，收到pong则成功，并且重写方法，在断线时调用重连方法即可</p>
                <p>ConcurrentHashMap和HashMap的区别（我说我先将一下HashMap吧，put方法get方法扩容机制blablabla，面试官：你讲一下两者的区别就行啦，估计是知道我们都背得滚瓜烂熟了）
                </p>
                <p>Redis应用场景（不顺便问问内部的数据结构么…）<br>
                    排行榜（zset的权重），热点数据 = 缓存（淘汰机制，LRU FIFO，时间过期），异步的消息队列（list），计数器，分布式锁。</p>
                <p>计数器原理（由于单线程，可以避免并发问题，保证不会出错，而且100%毫秒级性能！爽。命令：INCRBY）</p>
                <p>全局id生成。（单线程避免并发问题）<br>
                    介绍一下快排（复杂度也没问，就说了一下步骤和原理）</p>
                <p>何时毕业？你的未来职业规划是怎样的？（我说我想学习一下高并发、分布式相关的）</p>
                <p>你还有什么要问我的？（我问了部门平时主要业务是什么，后端主要做什么工作）<br>
                    面完后我感觉自己肯定GG了，当时已经做好看到“已回绝”的打算了，结果我打开网页一看——“待安排面试”，心里也是舒了一口气。<br>
                    阿里二面（3.27 32min）<br>
                    当时约好酷家乐一面的，然后突然阿里的电话打过来了，说要进行二面。谁知道面试官看我简历里有一个蓝桥杯的省奖（本来只是为了凑简历的获奖情况一栏…毕竟省奖太烂了跟没有一样）<br>
                    自我介绍<br>
                    项目经历<br>
                    你觉得在大学里学哪方面的东西更有价值？</p>
                <p>数据结构的理解、区别、优缺点、实现原理（数组、链表、栈、队列）？</p>
                <p>动态规划、贪心算法有没有解决过实际问题？</p>
                <p>没有，但是它们的思想都挺适合解决实际问题。</p>
                <p>数据库三大范式？<br>
                    第一<br>
                    第二<br>
                    第三</p>
                <p>进程调度算法？适用场景？<br>
                    FIFO，时间片轮转，优先级调度，短作业优先</p>
                <p>操作系统虚拟内存管理？<br>
                    虚拟内存主要是分页和分段。<br>
                    一个页面映射磁盘的一块空间，一般是8k和16k，根据需要调度到内存中。<br>
                    物理上分页，使用多级页表加页表缓存，同时配备地址转换器。<br>
                    逻辑上分段，避免内存段、越界访问。<br>
                    段页式结合，集两者之大成。<br>
                    面向对象与面向过程的区别？<br>
                    按照顺序写代码<br>
                    二面回答太烂了，面试官面了30分钟就不想问了。本来自己准备得多的JVM、计算机网络、多线程、数据库全都没问，后来想想应该要引导一下面试官往那方面问的。哎，还是自己太渣…</p>
                <p>作者：家有二呆<br>
                    链接：https://www.nowcoder.com/discuss/71012?type=2&amp;order=3&amp;pos=673&amp;page=1<br>
                    来源：牛客网<br>
                    阿里新零售正式一面面经。15分钟搞定了简历面，等了两周多，等来了一面，一面的画风有点突变，能感觉得到面试官是在看边找题目边问问题的，没有沿着问题继续探索，</p>
                <p>前面基础题都很简单（TCP/UDP区别，数据库索引，进程与线程区别，jvm内存区域划分，并发编程），</p>
                <p>数据库问的很多（数据库引擎，区别），直接让我写查询语句，由于条件达到四个，我就没答上来。</p>
                <ol>
                    <li>区别：<br>
                        （1）事务处理：<br>
                        MyISAM是非事务安全型的，而InnoDB是事务安全型的（支持事务处理等高级处理）；<br>
                        （2）锁机制不同：<br>
                        MyISAM是表级锁，而InnoDB是行级锁；<br>
                        （3）select ,update ,insert ,delete 操作：<br>
                        MyISAM：如果执行大量的SELECT，MyISAM是更好的选择<br>
                        InnoDB：如果你的数据执行大量的INSERT或UPDATE，出于性能方面的考虑，应该使用InnoDB表<br>
                        （4）查询表的行数不同：<br>
                        MyISAM：select count(<em>) from table,MyISAM只要简单的读出保存好的行数，注意的是，当count(</em>)语句包含
                        where条件时，两种表的操作是一样的<br>
                        InnoDB ： InnoDB 中不保存表的具体行数，也就是说，执行select count(*) from table时，InnoDB要扫描一遍整个表来计算有多少行<br>
                        （5）外键支持：<br>
                        mysiam表不支持外键，而InnoDB支持</li>
                    <li>为什么MyISAM会比Innodb 的查询速度快。<br>
                        INNODB在做SELECT的时候，要维护的东西比MYISAM引擎多很多；<br>
                        1）数据块，INNODB要缓存，MYISAM只缓存索引块， 这中间还有换进换出的减少；<br>
                        2）innodb寻址要映射到块，再到行，MYISAM 记录的直接是文件的OFFSET，定位比INNODB要快<br>
                        3）INNODB还需要维护MVCC一致；虽然你的场景没有，但他还是需要去检查和维护<br>
                        MVCC ( Multi-Version Concurrency Control )多版本并发控制</li>
                    <li>应用场景<br>
                        MyISAM适合：(1)做很多count 的计算；(2)插入不频繁，查询非常频繁；(3)没有事务。<br>
                        InnoDB适合：(1)可靠性要求比较高，或者要求事务；(2)表更新和查询都相当的频繁，并且行锁定的机会比较大的情况。</li>
                </ol>
                <p>总结一下就是：<br>
                    1 innodb支持外键，事务以及行级锁，另外还支持聚簇索引。</p>
                <p>2 而mysiam不支持上述特性，但是他在count场景速度快（因为保存了行数）。</p>
                <p>3 另外由于innodb需要维护聚簇索引，以及事务的MVCC特性，需要额外的开销。所以在查询方面，innodb可能会稍逊一筹。</p>
                <p>4 而插入方面，由于innodb支持行级锁，所以对于行级插入删除速度很快。<br>
                    最后一题是让我设计一个爬虫系统并将信息进行展示，用户可以查询，说是要看我系统设计思维。</p>
                <p>having语句：<br>
                    同样使用本文中的学生表格，如果想查询平均分高于80分的学生记录可以这样写：</p>
                <p>SELECT id, COUNT(course) as numcourse, AVG(score) as avgscore</p>
                <p>FROM student</p>
                <p>GROUP BY id</p>
                <p>HAVING AVG(score)&gt;=80;</p>
                <p>在这里，如果用WHERE代替HAVING就会出错</p>
                <p>------------------------------------------------更新一波，三面交叉面面完，是天猫的大佬面的，</p>
                <p>全程就一个技术点，lock和synchronized的区别，我就直接从对象头那开始讲，到AQS的基于state和cas。</p>
                <p>一个对象包含了对象头，对象元数据指针，以及补齐位。<br>
                    对象头主要包含了锁标识，gc阶段等信息。</p>
                <p>Mark Word。<br>
                    Mark Word用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程
                    ID、偏向时间戳等等。Java对象头一般占有两个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit），但是如果对象是数组类型，则需要三个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数组的大小，所以用一块来记录数组长度。下图是Java对象头的存储结构（32位虚拟机）：
                </p>
                <p>对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark
                    Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
                </p>
                <p>简单介绍了Java对象头，我们下面再看Monitor。</p>
                <p>1 偏向锁的实现：偏向锁不需要使用类似lock中的cas操作获得锁，而是通过判断对象头中maskword的偏向锁线程id判断自己是否获得了锁，如果不是则检查偏向锁是否开启，如果没有开启则使用（膨胀为轻量级锁），如果开启了就尝试用cas操作把线程id改为自己的id。
                </p>
                <p>2 轻量级锁的实现。把对象头中的maskword复制到当前线程的栈帧中，然后使用cas操作尝试使对象头的指针指向锁记录mask word，如果操作成功则获得锁，如果失败，则尝试自旋获取锁。</p>
                <p>3 如果轻量级锁升级，则变成重量级锁，也就是monitor in和monitor out。</p>
                <p>全程在问我有没有关注java新技术等，关注了哪些新技术等。对了，我从大二开始的项目经验，一个不漏的和面试官讲了，感觉面试官很想知道我具体做了什么。</p>
                <p>面完之后，找内推人问了一下状态，就差HR面了。================================================今天下午面完HR面了，阿里的面试流程全部走完了。有所思，有所悟。HR说四月下旬才会出结果，感觉HR面的一般，接下来就等消息了。祝大家都好运，拿到自己喜欢的offer。------------------------------------------------刚刚查看状态，已回绝。本次阿里春招到此结束。
                </p>
                <p>作者：以下是五月枪毙名单<br>
                    链接：https://www.nowcoder.com/discuss/70995?type=2&amp;order=3&amp;pos=676&amp;page=1<br>
                    来源：牛客网</p>
                <p>本人是学习ACM的，平时写C++比较多，莫名其妙的面了Java岗，</p>
                <p>你说我本来好好的写C++，怎么就突然来面Java了，</p>
                <p>面试的开始时候内心是崩溃的，一开始他问了我Java的Hashmap，</p>
                <p>我记得我用过一次 就简单的说了说，之后问了我快排，和Hash表</p>
                <p>以及Hash表的处理冲突问题，个人觉的不是很难，又问了我一些数据库和操作系统的知识，<br>
                    分布式，索引，B树啥的。</p>
                <p>然后是算法题，问找前100大的元素，我把他转换成了用nth_element求第K大元素的算法，听说正解是维护一个堆</p>
                <p>小顶堆。每次替换掉堆顶元素，之后进行调整，最后就是前100大的元素了。</p>
                <p>感觉，感觉两者复杂都差不多，面试官也就没问啥，又问了我的一些项目(其实也没啥项目)，又问了我最近看了什么书，扯了一些其他的</p>
                <p>最后他给我的建议是，要拓宽知识面。然后就没了。感觉阿里凉了。</p>
                <p>作者：aloserbird<br>
                    链接：https://www.nowcoder.com/discuss/70965?type=2&amp;order=3&amp;pos=682&amp;page=1<br>
                    来源：牛客网</p>
                <p>上个星期三阿里一面。。等了一个星期终于等到了阿里二面。。然而后面就是我没想到的。心情低落。在牛客上发泄下吧。然后顺便分享下面经。<br>
                    自我介绍<br>
                    介绍下你最有挑战的项目。</p>
                <p>项目中用过什么面向对象的设计原则（没答出来）<br>
                    开闭（不要改代码，通过继承或者实现接口来扩展），<br>
                    单一职责（一个类负责一件事情），<br>
                    依赖倒置（依赖接口，而不要依赖实现，否则改代码牵一发动全身，并且依赖接口可以动态注入实现类，也就是使用反射机制），<br>
                    里式替换（代码中子类可以替换父类），<br>
                    迪米特原则（对象之间不要有过多依赖，擅于使用中间层解耦）。<br>
                    项目中除了单例，工厂模式，用了什么设计模式解决了什么问题。（没答出来，没准备）<br>
                    观察者，也就是监听器模式，解决了生命周期问题，比如容器启动时做什么，容器关闭时做什么。</p>
                <p>代理模式，实现rpc调用少不了动态代理，aop也使用动态代理。</p>
                <p>适配器模式，经常需要使用适配器来适配数据表model和视图model，完成实例的转换。</p>
                <p>讲下spring是怎么加载类的。（源码）<br>
                    Spring初始化bean容器（外部表现为一个context），然后通过解析器解析每个bean，得到beandefinition实例，注册到map中，然后进行实例化，实例化阶段可能会有
                    前置和后工作需要完成，也可能需要包装为动态代理对象。</p>
                <p>当然，我们还需要先实例化依赖，把依赖注入到对象中。<br>
                    问个开发性的问题，假如广州没有一座消防站，现在问你要建立几座消防站，每个消防站要配多少名消防官兵，多少辆消防车。请你拿出一个方案。（我真的不知道他想要我干嘛）</p>
                <p>你对自己未来2到3年有什么样的规划。（这个问题大概是面试官看了下差不多时间了，安慰你一下，给你个台阶下）。答完之后，面试官说：那好，我们面试就到这里，好吗？拜拜········挂了电话。。</p>
                <p>此时一阵凉凉的清风吹过。。这TM是什么套路。全程23分钟。逃过了一面，最终还是死在了二面。。猝不及防的问题。真的，此时我才意识到面试真的不仅要考验你的技术，还要考你的语言表达能力，思维能力等各方面的能力。我语言表达能力真的不行。建议大家以后要多练练，好好准备。最好是能找几个朋友模拟下面试。。。面完我就只想回家过清明了。。祝大家好运。
                </p>
                <p>作者：policedog<br>
                    链接：https://www.nowcoder.com/discuss/70916?type=2&amp;order=3&amp;pos=695&amp;page=1<br>
                    来源：牛客网</p>
                <p>首先让自我介绍</p>
                <p>问项目，给了两个具体的情景让优化</p>
                <p>问项目在安全方面有什么考虑吗（并没有，被面试官鄙视了）<br>
                    1 前端过滤内容。<br>
                    2 后端检验文本内容是否合法，使用Java自带工具即可。<br>
                    3 加密密码，使用md5+盐的方式保证密码安全。<br>
                    4 过滤敏感内容，使用字典树完成，匹配成功就会被过滤。<br>
                    5 防止sql注入，所以要使用mybatis的#，自动加上转义，而不使用$（可能导致注入））。当然通过preparestatement也可以。</p>
                <p>数据库的行级锁和表级锁<br>
                    行级锁加在索引上。<br>
                    myisam的非select操作默认都要加表锁。</p>
                <p>悲观锁和乐观锁思想</p>
                <p>悲观锁需要加互斥锁来保持同步。<br>
                    乐观锁通过其他不使用互斥锁的手段保持同步，比如MVCC。<br>
                    2.MVCC 具体实现分析<br>
                    下面,我们通过InnoDB的MVCC实现来分析MVCC使怎样进行并发控制的.<br>
                    InnoDB的MVCC,是通过在每行记录后面保存两个隐藏的列来实现的,这两个列，分别保存了这个行的创建时间，一个保存的是行的删除时间。这里存储的并不是实际的时间值,而是系统版本号(可以理解为事务的ID)，没开始一个新的事务，系统版本号就会自动递增，事务开始时刻的系统版本号会作为事务的ID.下面看一下在REPEATABLE
                    READ隔离级别下,MVCC具体是如何操作的.</p>
                <p>id name 创建时间(事务ID) 删除时间(事务ID)<br>
                    1 yang 1 4<br>
                    2 long 1 undefined<br>
                    3 fei 1 undefined</p>
                <p>InnoDB会根据以下两个条件检查每行记录:<br>
                    a.InnoDB只会查找版本早于当前事务版本的数据行(也就是,行的系统版本号小于或等于事务的系统版本号)，这样可以确保事务读取的行，要么是在事务开始前已经存在的，要么是事务自身插入或者修改过的.<br>
                    b.行的删除版本要么未定义,要么大于当前事务版本号,这可以确保事务读取到的行，在事务开始之前未被删除.<br>
                    只有a,b同时满足的记录，才能返回作为查询结果.</p>
                <p>MVCC简介：</p>
                <p>1 innodb有快照读和当前读两种模式。</p>
                <p>2 当前读需要加锁，select lock in share mode上读锁或者lock for update直接上写锁。其他更新删除操作都属于当前读，需要加锁。</p>
                <p>3 快照读不加锁，使用select方法，执行的mvcc控制协议。</p>
                <p>4 行锁加在索引上，没索引则锁全表。</p>
                <p>后台缓存为啥选择redis，问了redis的数据结构，持久化<br>
                    1 Redis是内存数据库，速度快。<br>
                    2 redis支持分布式部署，分布式方案成熟，伸缩性好。<br>
                    3 redis支持多种数据结构，并且提供持久化方案。</p>
                <p>数据结构：string由sds实现。<br>
                    list由ziplist和quicklist实现。<br>
                    zset由跳表（快速查找key）+hash（快速得到score）实现。<br>
                    dict由hash实现。<br>
                    set由intset实现（自动转变数据类型）。</p>
                <p>aof采用追加日志的方式,记录日志.<br>
                    rds是快照方式存储数据文件。</p>
                <p>项目做压测了吗，用什么工具压测的，大概并发量有多少，你认为自己项目的性能瓶颈在什么地方<br>
                    JMeter是什么?<br>
                    JMeter是Apache开源项目的一部分。<br>
                    它最初是为了测试web服务器的性能而编写的，现在它已经作为一个自动化的测试工具和测试数据，以及用于web应用程序、文件服务器、web服务器甚至数据库的功能测试工具。我们将在本教程中探讨JMeter的重要特性。可以通过配置来模拟针对特定web服务器或应用程序的N个用户和线程。它为web应用程序生成一个模拟负载来度量其性能。此外，您还可以通过循环引发几个迭代来获得平均结果，实现断言，并查看测试结果的图形和统计表示。
                </p>
                <p>解释结果<br>
                    您可能会看到所有请求的状态都是“成功”(由绿色三角形表示，其中有一个复选标记)。在此之后，您可能最感兴趣的列是示例时间(ms)和延迟(在示例中没有显示)。<br>
                    延迟:在JMeter发送请求和收到初始响应时之间的毫秒数<br>
                    示例时间:服务器完全服务于请求(响应+延迟)的毫秒数<br>
                    样本数目：是指在测试过程中，总共想服务器发出的请求数目。成功的情况下等于你设定的并发数目×循环次数<br>
                    最新样本：他是代表时间的，表示服务器响应最后一个请求的时间。<br>
                    吞吐量 ： 表示服务器每分钟处理的请求数目。<br>
                    平均值 ： 总的运行时间除以发送到服务器的请求数目；<br>
                    偏离 ： 服务器响应时间变化、离散程度测量值的大小，或者，换句话说，就是数据的分布。<br>
                    中值 : 时间的数字，有一半的服务器响应时间低于该值而另一半高于该值。</p>
                <p>6).与测试服务器结合分析<br>
                    ssh登录到服务器上去看看cpu和内存的使用情况，使用top：</p>
                <p>大量请求同时过来怎么削峰<br>
                    消息队列。</p>
                <p>说一下rabbitmq的几个交换模式</p>
                <p>一条消息一个消费者，一条消息多个消费者，主题订阅。</p>
                <p>了解其他的消息队列吗？（并不了解）</p>
                <p>kafka，同样支持1对1和1对多</p>
                <p>JVM内存分区，内存泄露与内存溢出的区别<br>
                    堆，方法区，本地方法区，1.7方法区使用永久代实现，永久代别分散在多个地方，1.8方法区使用元数据区实现。</p>
                <p>而元数据区则由本地内存接管。</p>
                <p>遇到过项目频繁出现FULL GC的情况吗？怎么排查（项目规模小，并没有遇到过）<br>
                    性能调优步骤：</p>
                <p>GC:<br>
                    1 使用压测工具+监控工具完成性能排查，定位性能瓶颈。<br>
                    2 使用jstat或者visualvm定位gc的时间和次数，判定是gc问题。<br>
                    3 接着可以查阅gc日志或者用jmc这类工具查看gc具体情况。<br>
                    4 尝试改变jvm参数，比如内存大小，垃圾回收器方案等。</p>
                <p>内存：<br>
                    使用jmap转储内存dump文件进行分析。定位oom和内存泄漏问题，比如使用mat和jhat</p>
                <p>cpu：通过top+jstack定位进程的异常线程，跟踪调用堆栈，排查问题。<br>
                    也可以通过日志排查，当然通过tprofier直接排查耗时最多的方法，效果更好。</p>
                <p>平时怎么学习的，有什么要问我的吗</p>
                <p>4 二进制流中的信息当然就是tcp报文内容了，比如说是http报文，也可是序列化对象。<br>
                    5 四次挥手状态变化， fin1 fin2 ack timewait和closewait。<br>
                    发送报文sync携带随机数，回复报文ack就是随机数加一了。<br>
                    大写的ACK和SYNC指的是标识位。</p>
                <p>5 ：略<br>
                    6 ,7略<br>
                    8：有。好处：线程复用，方便管理和控制并发数，并且可以提交异步任务。<br>
                    最大线程数和cpu核心数有关吧，是核心数额整数倍，有效利用多核的计算能力。<br>
                    9 1。5倍扩容。扩容就是复制到新数组。</p>
                <p>ArrayList底层是数组，使用索引get，put，delete后调整。</p>
                <p>作者：好好复习<br>
                    链接：https://www.nowcoder.com/discuss/70790?type=2&amp;order=3&amp;pos=706&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里面试 面试官都挺和善的 就是自己太菜了 转专业的心累<br>
                    1面<br>
                    自我介绍<br>
                    ArrayList和linkedlist<br>
                    jvm工作原理<br>
                    然后就没问了 说你答的不是我想要的 不够深入 聊了聊人生 还是给了二面的机会</p>
                <p>2面<br>
                    聊项目20分钟<br>
                    你知道什么常用的人脸识别算法(项目相关)<br>
                    ArrayList和linkedlist<br>
                    get/post区别<br>
                    1url和限制内容长度<br>
                    2一次和两次http请求<br>
                    3场景<br>
                    什么是restful<br>
                    使用http的get，put，post和delete代表各种资源操作，并且由此定义api。<br>
                    docker和虚拟机区别 答得不好 只是根据自己使用经验做了对比 显然面试官不满意</p>
                <p>虚拟机可以虚拟硬件，并且提供虚拟的操作系统，重量级。<br>
                    比如VMware，而Linux支持KVM虚拟机，每个kvm虚拟机拥有虚拟内核。（完全虚拟化需要虚拟化内核，然后通过真实内核进行命令执行，而半虚拟化只需要把系统调用通过真正内核执行，其他可以通过更高效的方式执行）。<br>
                    一般配合qemu虚拟化其他设备，libvirt管理虚拟机。OpenStack建立在这套虚拟化基础之上。</p>
                <p>而docker则是基于linux的LXC容器基础，通过cgroup划分硬件资源，namespace划分进程空间，实现资源和进程的小隔间。同时通过桥接，host等方式使用网络，使用unionfs实现文件存储。
                </p>
                <p>cookie和session区别 我直接回答还没学计算机网络所以不知道</p>
                <p>面试官说你在知识深度和广度方面都需要加强 阿里希望招对技术专精的人</p>
                <p>过2天后状态变成已回绝 不亏 确实自己水平不够</p>
                <p>作者：Davie2<br>
                    链接：https://www.nowcoder.com/discuss/85735?type=2&amp;order=3&amp;pos=52&amp;page=1<br>
                    来源：牛客网</p>
                <p>1.介绍一个比较熟悉的项目，问项目具体细节，挺多</p>
                <p>2.说一下hashMap的底层，除了数组+链表，还可以用什么数据结构实现hashMap</p>
                <p>3.排序，时间复杂度，应用的场景</p>
                <p>空间复杂度为1<br>
                    1 插入排序，平均复杂度是On2，但是有序序列时只要On。冒泡排序类似，当序列有序时扫描一轮就是On。<br>
                    2 选择排序，无论如何都是on2。<br>
                    3 希尔排序，复杂度是Onlogn，实现复杂，记住即可。<br>
                    4 堆排序，时间复杂度稳定在Onlogn，每次都是插入，调整。</p>
                <p>空间复杂度不为1<br>
                    1 归并排序，复杂度是Onlogn，无论序列是否有序，都要全部扫描一遍、并且需要额外数组，空间复杂度为On；<br>
                    2
                    快速排序，复杂度是Onlogn，partition方法复杂度是on，递归复杂度则是logn，并且对于每个数的一轮paritition都需要额外空间，而递归情况下放大了空间使用，也就是O（nlogn）的空间复杂度。快排在有序情况下复杂度变为O(n2)，因为每次递归分为1和n-1，需要n次递归，所以复杂度为O（n2）。<br>
                    3基数排序，根据位数决定。<br>
                    4 计数排序，桶排序，都需要额外数组，复杂度为O（n）。</p>
                <p>稳定性：<br>
                    情绪不稳定，快些选一堆朋友来聊天吧。<br>
                    快速排序，选择排序，希尔排序，堆排序，都是不稳定的。</p>
                <p>4.堆排序和快排的区别和应用</p>
                <p>1 堆排序用于海量数据找前k个数。</p>
                <p>2 快排主要用于小数据量乱序数据的排序。</p>
                <p>3 而归并适合小数据量的任意序列排序。</p>
                <p>5.进程和线程的区别</p>
                <p>6.进程间的通信，线程间的通信<br>
                    五种<br>
                    Java并发工具，原生线程方法</p>
                <p>7.TCP和IP的区别</p>
                <p>8.为什么TCP是可靠传输的</p>
                <p>1 滑动窗口实现了有序传输，确认传输，超时重传等机制确保可靠性。<br>
                    2 连续发送和确认提高效率，缓存数据包提高效率。<br>
                    3 检验和保证正确性。<br>
                    4 拥塞控制避免网络拥堵。流量控制保证收发速率合理</p>
                <p>9.在线测评：给一个时间戳，算出具体的年和月（时间戳是从格林威治时间1970年01月01日00时00分00秒起至现在）<br>
                    注意：不能使用simpleFormat，date这些时间类，只能通过数学转换<br>
                    问题：1）假如时间戳小于0呢<br>
                    2）怎么区分公元前和公元后</p>
                <p>import java.util.Scanner;<br>
                    public class Timel {</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">private static Scanner in;

public static void main(String[] args) {//实现当前系统时间戳的转换，输入一个有效的时间进行转换
    System.out.println("时光机系统开启，当前北京时间：");
    TimeCp now=new TimeCp(System.currentTimeMillis()/1000);
    System.out.println(now.cpTime());
    System.out.println("请输入想去的时间点距离(1970为起点)：");
    in = new Scanner(System.in);
    long tp=in.nextLong();
    TimeCp some=new TimeCp(tp);
    System.out.println(some.cpTime());
    System.out.print("你穿越到");
    System.out.println(some.cpTime()+"是否查看其他几区时间yes-&gt;1");
    int a=in.nextInt();
    if(a==1)
    {
    System.out.println(some.timeArea(some.cpTime()));
    }
}
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li><li style="color: rgb(153, 153, 153);">13</li><li style="color: rgb(153, 153, 153);">14</li><li style="color: rgb(153, 153, 153);">15</li><li style="color: rgb(153, 153, 153);">16</li><li style="color: rgb(153, 153, 153);">17</li><li style="color: rgb(153, 153, 153);">18</li><li style="color: rgb(153, 153, 153);">19</li></ul></pre>
                <p>}<br>
                    class TimeCp<br>
                    {<br>
                    private long time;<br>
                    public TimeCp(long x)<br>
                    {<br>
                    time=x;<br>
                    }<br>
                    public long[] cpTime()//构造器，将时间戳转换为年月日…格式<br>
                    {<br>
                    long year=1970,month=1,day=1,hour=0,minute=0,second=0;<br>
                    second=time%60;//取模是算法中非常有用的一个技巧，从奇偶数的判别到素数的判别，从模幂运算到最大公约数的求法，猴子选王（抽象的讲它可以实现循环）<br>
                    minute=time%3600/60;//不足一小时的秒数作为分钟<br>
                    hour=(time+86400)%86400/3600+8;<br>
                    day=time/86400+1;<br>
                    while(day&gt;=32)//因为每个月的天数没有太大规律（有发现的朋友可以优化），所以用if进行年的循环。主要思想就是天数减完，年加，不足就退出，还有就是闰年的问题<br>
                    {<br>
                    day=day-31;<br>
                    month++;<br>
                    if(((year%4)<mark>0&amp;&amp;(year%100)!=0)||(year%400</mark>0))<br>
                    {<br>
                    if(day&gt;=30)<br>
                    {<br>
                    day=day-29;<br>
                    month++;<br>
                    }<br>
                    }<br>
                    else<br>
                    {<br>
                    if(day&gt;=29)<br>
                    {<br>
                    day=day-28;<br>
                    month++;<br>
                    }</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">        }
        if(day&gt;=32)
        {
            day=day-31;
            month++;
        }
        if(day&gt;=31)
        {
            day=day-30;
            month++;
        }
        if(day&gt;=32)
        {
            day=day-31;
            month++;
        }
        if(day&gt;=31)
        {
            day=day-30;
            month++;
        }
        if(day&gt;=32)
        {
            day=day-31;
            month++;
        }
        if(day&gt;=32)
        {
            day=day-31;
            month++;
        }
        if(day&gt;=31)
        {
            day=day-30;
            month++;
        }
        if(day&gt;=32)
        {
            day=day-31;
            month++;
        }
        if(day&gt;=31)
        {
            day=day-30;
            month++;
        }
        if(day&gt;=32)
        {
            day=day-31;
            month++;
            month=1;
            year++;
        }
    }
System.out.println(year+"-"+month+"-"+day+"  "+hour+":"+minute+":"+second);
long[] tmp={year,month,day,hour,minute,second};
    return tmp;
}
public long timeArea(long[] x)//时区转换
{
    System.out.println("七区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-1)+":"+x[4]+":"+x[5]);
    System.out.println("六区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-2)+":"+x[4]+":"+x[5]);
    System.out.println("五区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-3)+":"+x[4]+":"+x[5]);
    System.out.println("四区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-4)+":"+x[4]+":"+x[5]);
    System.out.println("三区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-5)+":"+x[4]+":"+x[5]);
    System.out.println("二区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-6)+":"+x[4]+":"+x[5]);
    System.out.println("一区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-7)+":"+x[4]+":"+x[5]);
    System.out.println("本区"+x[0]+"-"+x[1]+"-"+x[2]+"  "+(x[3]-8)+":"+x[4]+":"+x[5]);
    return 0;
}
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li><li style="color: rgb(153, 153, 153);">13</li><li style="color: rgb(153, 153, 153);">14</li><li style="color: rgb(153, 153, 153);">15</li><li style="color: rgb(153, 153, 153);">16</li><li style="color: rgb(153, 153, 153);">17</li><li style="color: rgb(153, 153, 153);">18</li><li style="color: rgb(153, 153, 153);">19</li><li style="color: rgb(153, 153, 153);">20</li><li style="color: rgb(153, 153, 153);">21</li><li style="color: rgb(153, 153, 153);">22</li><li style="color: rgb(153, 153, 153);">23</li><li style="color: rgb(153, 153, 153);">24</li><li style="color: rgb(153, 153, 153);">25</li><li style="color: rgb(153, 153, 153);">26</li><li style="color: rgb(153, 153, 153);">27</li><li style="color: rgb(153, 153, 153);">28</li><li style="color: rgb(153, 153, 153);">29</li><li style="color: rgb(153, 153, 153);">30</li><li style="color: rgb(153, 153, 153);">31</li><li style="color: rgb(153, 153, 153);">32</li><li style="color: rgb(153, 153, 153);">33</li><li style="color: rgb(153, 153, 153);">34</li><li style="color: rgb(153, 153, 153);">35</li><li style="color: rgb(153, 153, 153);">36</li><li style="color: rgb(153, 153, 153);">37</li><li style="color: rgb(153, 153, 153);">38</li><li style="color: rgb(153, 153, 153);">39</li><li style="color: rgb(153, 153, 153);">40</li><li style="color: rgb(153, 153, 153);">41</li><li style="color: rgb(153, 153, 153);">42</li><li style="color: rgb(153, 153, 153);">43</li><li style="color: rgb(153, 153, 153);">44</li><li style="color: rgb(153, 153, 153);">45</li><li style="color: rgb(153, 153, 153);">46</li><li style="color: rgb(153, 153, 153);">47</li><li style="color: rgb(153, 153, 153);">48</li><li style="color: rgb(153, 153, 153);">49</li><li style="color: rgb(153, 153, 153);">50</li><li style="color: rgb(153, 153, 153);">51</li><li style="color: rgb(153, 153, 153);">52</li><li style="color: rgb(153, 153, 153);">53</li><li style="color: rgb(153, 153, 153);">54</li><li style="color: rgb(153, 153, 153);">55</li><li style="color: rgb(153, 153, 153);">56</li><li style="color: rgb(153, 153, 153);">57</li><li style="color: rgb(153, 153, 153);">58</li><li style="color: rgb(153, 153, 153);">59</li><li style="color: rgb(153, 153, 153);">60</li><li style="color: rgb(153, 153, 153);">61</li><li style="color: rgb(153, 153, 153);">62</li><li style="color: rgb(153, 153, 153);">63</li><li style="color: rgb(153, 153, 153);">64</li><li style="color: rgb(153, 153, 153);">65</li><li style="color: rgb(153, 153, 153);">66</li><li style="color: rgb(153, 153, 153);">67</li><li style="color: rgb(153, 153, 153);">68</li><li style="color: rgb(153, 153, 153);">69</li><li style="color: rgb(153, 153, 153);">70</li></ul></pre>
                <p>不会！<br>
                    大概记得就这些了，有几个问题没想起来，等想起来在来补充吧哈哈<br>
                    最后问了一句，最近在看什么书？然后就没有然后了，面试官人很nice（喜欢边听边说嗯哼，很迷哈哈）</p>
                <p>作者：vec_<br>
                    链接：https://www.nowcoder.com/discuss/70568?type=2&amp;order=3&amp;pos=729&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里技术二面:</p>
                <p>0.上周四晚上过的一面，面经已发，今天下午接到电话，当时在上课，然后约了晚上<br>
                    ，同样，括号为回答内容，仅个人看法，如果错误欢迎指出，大家都加油！</p>
                <p>1.问了下部门意愿，深圳阿里(国际部)or广州阿里(文娱部)，面试官是深圳的，我也答了深圳</p>
                <p>2.做过什么项目，简单介绍一下(ssh,ssm)</p>
                <p>3.为什么选择Spring(把优点说了一遍)<br>
                    ioc和aop</p>
                <p>4.你觉得Spring设计得最好的是？(答IOC,AOP)</p>
                <p>5.分别谈谈ioc,aop的底层原理(反射机制，动态代理，具体继承的类实现的接口)<br>
                    反射机制进行实例化，ioc让类只依赖接口，不依赖实例，实现了依赖倒置，并且通过配置文件配置实际对象，完成了对实际类型的解耦，只对接口依赖。</p>
                <p>动态代理实现了aop。jdk动态代理可以代理实现了接口的类。cglib可以代理任何类。</p>
                <p>6.聊聊数据库的事务(acid,4个隔离级别，底层实现:加锁)</p>
                <p>mvcc和加锁。</p>
                <p>7.可重复读隔离级别为何出现幻读(InnoDB的行级锁与表级锁，解决方案)</p>
                <p>可重复读一般只加行级锁就可以了。所以不能避免插入产生幻读，可以使用next-key lock这种锁来避免插入，避免了幻读。</p>
                <p>当然也可以使用MVCC，判断版本号是不是比自己早，就不必读取这部分数据了。</p>
                <p>如果用序列化级别实现，则要求所有事务操作串行化，也就是使用表锁，这里用的是读锁。</p>
                <p>8.谈谈乐观锁，悲观锁(mvcc,版本号)</p>
                <p>mvcc</p>
                <p>9.介绍一下tcp握手过程</p>
                <p>注意syn和SYN的区别</p>
                <p>10.介绍一下Java并发包(并发容器，同步设备，原子对象，锁，fork-join，执行器，详细介绍了concurrent Hashmap，Countdownlatch的底层实现及应用场景)</p>
                <p>1 并发容器：chm。写时复制容器，跳表。</p>
                <p>2 原子基础类型，原子引用。</p>
                <p>3 Lock，读写锁，内部基于AQS</p>
                <p>4 fork-join工作窃取，每个线程处理自己的一个队列，处理完了找别人拿，fork出来额队列放到公共队列中，等待执行。</p>
                <p>5 执行器，实现类一般是excutors的工厂方法，也可以自定义threadexcutor。</p>
                <p>6 chm的帮助扩容机制，原来单线程变为多线程。countdownlatch底层用aqs的共享锁模式实现。</p>
                <p>11.分别介绍一下NIO,AIO,BIO(非阻塞，同步非阻塞，阻塞)</p>
                <p>BIO就是直接使用io流交互，操作都是会阻塞的。</p>
                <p>同步一般指的是线程阻塞在系统调用上。这个阻塞是不可避免的，除非内核支持AIO。</p>
                <p>阻塞和非阻塞指的是使用线程阻塞等待io就绪还是线程轮询方式等待。</p>
                <p>NIO包括channel和绑定的buffer，channel可以管理多个socket，socket可以复用buffer。<br>
                    使用selector注册socket事件，使用key遍历就绪事件，执行IO操作。<br>
                    我们可以开启一个线程轮询key，而不需要进行阻塞，这就是IO的多路复用，多个io请求复用一个selector，复用一个buffer。底层当然还是epoll。</p>
                <p>AIO就是让内核完成IO操作，我们只需要注册回调函数即可，内核完成io操作后会进行通知。</p>
                <p>12.同步和异步的区别，同步的实现原理(加锁，Java种锁的底层实现，AQS,CAS)<br>
                    synchronized同步，使用操作系统的mutex 锁。其他线程不能进入该代码区，需要切换到内核态。</p>
                <p>lock使用了AQS的state实现，采用cas加等待队列的方式模拟锁，并且也会用到同步工具类进行线程阻塞。</p>
                <p>13.参加过ACM吗？都了解哪些算法(排序，查找，树的遍历，动态规划，贪心，详细介绍快排的实现，时间复杂度)</p>
                <p>14.数学测试题:如何快速计算出7<sup>128在计算机内占多少字节(取8</sup>128得131位，再换成字节，面试官没给结果，不知这样算对不对？)</p>
                <p>15.在学校成绩怎样(答了还行，面试官继续问具体情况，再答绩点，综测均第一………⊙﹏⊙我想低调的…)</p>
                <p>16.英语水平怎样？(答了四六级分数)</p>
                <p>17.口语怎样？(答一般，从环境因素客观解释了原因，说目前看文档没有问题，口语只要有环境有决心去练相信可以掌握，表现出学习的态度)</p>
                <p>18.有什么想问我的(问了技术学习建议，面试官还是说(阿里)重视基础，要能阅读源码解底层原理，其他项目或实践经验都是加分项)</p>
                <p>19.面了40 分钟</p>
                <p>20.这次主要考察综合能力，不仅仅是技术，关注基础的底层实现</p>
                <p>作者：没有288<br>
                    链接：https://www.nowcoder.com/discuss/70562?type=2&amp;order=3&amp;pos=730&amp;page=1<br>
                    来源：牛客网</p>
                <p>跟一面一样，没有任何预兆，在上课的时候打来了。整个过程感觉面试官很匆忙，听我的回答很多都只听了一半就问下一个问题。不多说了，直接上问题：</p>
                <ol>
                    <li>
                        <p>自我介绍</p>
                    </li>
                    <li>
                        <p>java7和8的新特性(居然忘了默认方法。。)</p>
                    </li>
                </ol>
                <p>函数式和lambda</p>
                <p>optional判空</p>
                <p>接口的默认方法</p>
                <p>日期api</p>
                <p>集合类的流式api</p>
                <p>更新jdk，比如chm和hashmap。</p>
                <p>删除永久代，增加元数据区。</p>
                <ol start="3">
                    <li>
                        <p>ThreadLocal<br>
                            本质是一个hashmap。内存泄漏解决</p>
                    </li>
                    <li>
                        <p>Full GC原理<br>
                            一般起因是young gc不能解决问题。<br>
                            young gc + old gc。<br>
                            触发原因可能有，堆空间不足分配对象，晋升失败，存活区空间不足等。</p>
                    </li>
                    <li>
                        <p>AOP</p>
                    </li>
                    <li>
                        <p>Future类干嘛的</p>
                    </li>
                </ol>
                <p>接收callable的返回值，futuretask则可以一人分饰两角。</p>
                <ol start="7">
                    <li>3:15分时针分针的夹角度数</li>
                </ol>
                <p>因为15分是1/4,3点到4点之间前进的角度是1/4 * 1/12 = 1/48<br>
                    所以三点15分时针的角度是3 * 1/12 + 1/48 = 13/48。<br>
                    两者差距是1/48,360*1/48就是7.5度</p>
                <ol start="8">
                    <li>static 方法和对象方法在同步的时候的区别</li>
                </ol>
                <p>static是类方法，与对象无关。</p>
                <ol start="9">
                    <li>
                        <p>从大文本中找到自己名字的数量(楼主回答kmp，面试官说java中有个很简单的方法可以解决。我：难道正则？面试官：。。)</p>
                    </li>
                    <li>
                        <p>mysql连接查询</p>
                    </li>
                </ol>
                <p>select * from t1 where a.t = b.t</p>
                <ol start="11">
                    <li>
                        <p>项目的各种问题</p>
                    </li>
                    <li>
                        <p>分布式相关的知识(没做过分布式方面的，凉凉)</p>
                    </li>
                </ol>
                <p>1cap<br>
                    2base<br>
                    3一致性协议<br>
                    4一致性算法paxos和raft，zab<br>
                    5 分布式缓存，session，消息队列。<br>
                    6 负载均衡，分布式数据库，hadoop，zk。<br>
                    7 云计算，大数据。</p>
                <ol start="13">
                    <li>
                        <p>红黑树(凉凉。。)<br>
                            特性，调整。</p>
                    </li>
                    <li>
                        <p>相对其他人的优势</p>
                    </li>
                </ol>
                <p>1 学习能力和学习方法<br>
                    2 规划和坚持<br>
                    3 主动性</p>
                <p>总结：因楼主是双非而且非科班，算法这方面的东西太弱，红黑树只是听说过然后知道在HashMap中有使用。。而且楼主做的项目比较小，面试官对项目这块不太满意。总之，感觉凉凉。。希望各位加油！！！</p>
                <p>双非二本软件工程专业，面的是菜鸟网络。<br>
                    这一个月都在面试，终于把技术面完了。就等HR了，革命尚未成功。加油<br>
                    先留图，以后再发面经。有什么你可以留言，我晚上有空会一一回复的。</p>
                <p>作者：这就是我的逃跑路线，jojo！<br>
                    链接：https://www.nowcoder.com/discuss/70311?type=2&amp;order=3&amp;pos=778&amp;page=2<br>
                    来源：牛客网</p>
                <p>阿里：<br>
                    一面：简单问了问多线程，之后怼项目<br>
                    问：支付宝回调时回传失败如何处理<br>
                    答：订单支付根据订单id更新无问题，充值生成id防止重复充值</p>
                <p>每次支付生成一个新id，只能支付当前id对应的订单，否则支付失败。<br>
                    所以如果支付成功但是回传失败，再次支付时订单号和支付对应id不同，不会完成支付。</p>
                <p>问：如果回调后本机服务处理过慢支付宝又回调怎么办<br>
                    答：使用分布式锁</p>
                <p>如果本机服务处理过慢，导致支付宝再次回调，可以使用幂等性接口。</p>
                <p>问：分布式锁怎么实现？<br>
                    答：mysqlrediszookeeper</p>
                <p>1 mysql把某条记录更新为1，解锁时更新为0，可能更新失败，导致无法获取锁。</p>
                <p>2 redis使用setnx，超时过期的set，事务性的set(更新和设置时间放在一个事务中完成，可以使用lua脚本实现）。<br>
                    如果单实例不够，可以使用分布式的redis锁方案，redission。</p>
                <p>3 zookeeper在目录树下新建一个节点即可。<br>
                    问：找一个说下<br>
                    答：redis<br>
                    setnx</p>
                <p>问：获取锁挂掉怎么办<br>
                    答：setnx时设置过期值</p>
                <p>问：脑裂怎么办<br>
                    答：存储获取锁的对象，恢复后检查持有锁的是否为自己，不是则回滚</p>
                <p>redis脑裂可能导致两个master同时出现，应该通过增加心跳链路的冗余来保证心跳可靠。</p>
                <p>问：你项目中token怎么防止别人攻击认证系统<br>
                    答：jjwt可以验证是否为自己生成的，不是则不去查询redis</p>
                <p>问：具体原理是啥<br>
                    答：不会，告辞</p>
                <p>问：redis缓存了解么？<br>
                    答：没用过但是了解</p>
                <p>了解过，lru，过期。</p>
                <p>问：知道缓存穿透么？怎么解决<br>
                    答：对查询进行验证，短时间缓存空值，顺便聊了缓存雪崩的解决方法，缓存设置过期时间随机分布</p>
                <p>1 查询验证，过滤部分查询。</p>
                <p>2 短时间缓存空值，避免大量的缓冲穿透攻击，直接返回空值即可。</p>
                <p>3 缓存雪崩意思是同一时间大批缓存失效，数据库遭殃，此时应该设置过期时间随机分布</p>
                <p>菜鸡加面，简称菜面（太菜才会加的面，一面多线程那块出了个低级错误）<br>
                    在线编程，多线程轮流输出，提交后面试官提了个问题，解决了后结束</p>
                <p>join大法好</p>
                <p>二面：<br>
                    问：mysq使用多个索引的查询怎么运行<br>
                    答：and交集</p>
                <p>问：or呢？<br>
                    答：只知道or会出问题不知道为啥（大脑一片空白，实际上是or带了非索引会出问题）</p>
                <p>or如果使用了非索引字段则整个查询都不会走索引。</p>
                <p>前缀匹配索引不要求where条件的先后顺序，只要求出现就可以</p>
                <p>问：订单id量大怎么解决<br>
                    答：消息中间件缓冲，分奇偶生成id，分片生成id（实际为事先生成好）<br>
                    消息中间件削峰。</p>
                <p>问：尬聊三连发<br>
                    1.什么样能成为一个好的程序员<br>
                    1 技术基础扎实，对新技术有热情。</p>
                <p>2 对整体业务，架构要有比较好的认识，要深入理解自己的技术栈。</p>
                <p>3 重视协作，重视质量和迭代效率。<br>
                    2.问题在同事间出现分歧怎么解决<br>
                    协商<br>
                    3.你认为同事会希望你成为一个什么样的人<br>
                    能够独当一面，懂技术也懂业务，能协作，易交流和沟通，有责任感。</p>
                <p>尬聊三连加上10天没三面消息，基本gg，状态永远停滞在面试中</p>
                <p>三面：早上还没睡醒莫名其妙来的三面。。都快一个月了。。<br>
                    问：自我介绍<br>
                    答：blabla</p>
                <p>问：java用几年了<br>
                    答：两三年</p>
                <p>问：看你知道并发，进程间交互方式了解不？<br>
                    答：匿名管道，命名管道。。。。。bla<br>
                    1 管道（半双工），消息队列（存储消息，通知进程），信号量（封装好的管程），socket，共享内存，</p>
                <p>问：线程的锁有啥<br>
                    答：lock类，syn锁，volatile可见性，原子类，syn的实现是（面试官：打住，打住）</p>
                <p>问：final的用法<br>
                    答：类，方法，变量</p>
                <p>问：final在多线程中的用法<br>
                    答：防止其他线程修改数据？？(面试官：mdzz）<br>
                    在旧的Java内存模型中
                    ，最严重的一个缺陷就是线程可能看到final域的值会改变。比如，一个线程当前看到一个整形final域的值为0（还未初始化之前的默认值），过一段时间之后这个线程再去读这个final域的值时，却发现值变为了1（被某个线程初始化之后的值）。最常见的例子就是在旧的Java内存模型中，String的值可能会改变（参考文献2中有一个具体的例子，感兴趣的读者可以自行参考，这里就不赘述了）。在旧的Java内存模型中
                    ，最严重的一个缺陷就是线程可能看到final域的值会改变。比如，一个线程当前看到一个整形final域的值为0（还未初始化之前的默认值），过一段时间之后这个线程再去读这个final域的值时，却发现值变为了1（被某个线程初始化之后的值）。最常见的例子就是在旧的Java内存模型中，String的值可能会改变（参考文献2中有一个具体的例子，感兴趣的读者可以自行参考，这里就不赘述了）。
                </p>
                <p>为了修补这个漏洞，JSR-133专家组增强了final的语义。通过为final域增加写和读重排序规则，可以为java程序员提供初始化安全保证：只要对象是正确构造的（被构造对象的引用在构造函数中没有“逸出”），那么不需要使用同步（指lock和volatile的使用），就可以保证任意线程都能看到这个final域在构造函数中被初始化之后的值。<br>
                    问：jvm了解么？<br>
                    答：还行</p>
                <p>问：jvm命令哪些？<br>
                    答：设置堆容量，新老年代比例，设置保证分配，cms设置碎片压缩时间，输出回收细节等。。。<br>
                    xmx堆最大值，xms为堆初始值，xmn为新生代内存，xss为栈内存大小。survivorratio为一个survivor区的比例，一般是8，也就是eden和from，to比例为8:1:1</p>
                <p>另外还可以设置阈值，设置回收器，设置永久代大小（1.8不行）</p>
                <p>问：jvm有回收方法了为啥还会内存泄露<br>
                    答：堆泄露，栈，方法区分别举例</p>
                <p>静态容器持有大量对象不释放。<br>
                    threadlocal内存泄漏。<br>
                    数据库连接池，监听器，lock等情况。</p>
                <p>问：附近的人怎么实现<br>
                    答：地图分区块，用户存区块，查附近人按区块查，最多跨4个区，用户按区设置索引（其实是geohash，可惜之前没准备）</p>
                <p>geohash，redis</p>
                <p>问：时间空间复杂度多少？<br>
                    答：没答好。。。正式进入凉凉尬聊阶段</p>
                <p>问：项目是个啥？<br>
                    答：小型电商项目，卖建材的</p>
                <p>问:你写的接口端开发，你是做啥的？<br>
                    答：于安卓和ios交互的全部内容，全部用json返回值，登陆状态用的token</p>
                <p>问：交互用的啥协议？<br>
                    答：就是自带的，普通http。。。</p>
                <p>问：token用来干啥？<br>
                    答：保持登录状态，用的开源包，用来实现一个类似session的玩意</p>
                <p>问：用户密码怎么存的？是明文？<br>
                    答：md5。。</p>
                <p>编辑这个帖子时突如其来的hr面：<br>
                    hr小姐姐表示看到我之前经历了这几次面试所以现在开始hr面<br>
                    问题：<br>
                    项目介绍：项目目标，个人职责，最有成就的点，有挑战的点<br>
                    学习生活：学校排名，平时时间分配，毕业时间，研究方向，实验室项目属性<br>
                    个人问题：优缺点（解释了半天，超级尬聊，我这人特悲观完全想不出自己啥优点以及不太致命的缺点，尬聊到要死）<br>
                    实习相关：实习时间，工作地点选择，毕业时间</p>
                <p>最后说最后会4月末给消息，过不过都会标明，等呗</p>
                <p>总结：一面除了加密细节没研究过有点失败以外都很顺利，成功把面试官引到公式化回答的套路中去了，<br>
                    二面回答的很差，也是因为自己确实没有相关的经验（还是太菜），<br>
                    三面，挂的理由跟腾讯类似，都是有些解决方案说不好，自己确实没有类似经验，也没背全这类的问题的解答。。<br>
                    整个阿里过程对我来说是最难的也是最漫长的一个，从2月15日到今天4月14日晚，整整2个月，最后估计也不会要我，不过也非常感谢几个面试官（大神）能抽出自己宝贵的时间跟我这个菜鸡考一考技术，不管最终是否能拿到offer，这段过程对我整个春招以及秋招都会有很大的正面意义吧（大概）
                </p>
                <p>作者：没有288<br>
                    链接：https://www.nowcoder.com/discuss/70172?type=2&amp;order=3&amp;pos=785&amp;page=1<br>
                    来源：牛客网</p>
                <p>没有任何防备，今早十一点接到了阿里的一面电话。首先很感谢阿里给的面试机会！面试官人很好，对我的建议也很中肯！下面就说下问的问题，攒个人品。。<br>
                    1.印象最深刻的项目</p>
                <p>2.项目中的excel处理操作如果遇到大文件内存容量不足怎么处理。(内心有点崩溃。。平时用的时候根本没考虑这么多，就说了下自己的一些想法)</p>
                <p>3.jvm内存，堆栈以及垃圾回收</p>
                <p>4.类加载机制，如果程序自定义一个java.lang.Object会发生什么<br>
                    不会被加载</p>
                <p>5.乐观锁与悲观锁</p>
                <p>6.线程池实现原理</p>
                <p>7.HashMap与ConcurrentHashMap的区别</p>
                <p>8.快排</p>
                <p>9.最短路径问题</p>
                <p>10.2017的2017次方的最后一位数是什么</p>
                <p>11.为什么不想读研</p>
                <p>12.什么时候能去实习</p>
                <p>大概就上面那些，总体感觉一般，有些问题没回答好，感觉凉了。。</p>
                <p>作者：Michael2397<br>
                    链接：https://www.nowcoder.com/discuss/70117?type=2&amp;order=3&amp;pos=793&amp;page=1<br>
                    来源：牛客网</p>
                <p>2018.3.23上午师兄内推了我的简历，中午我用两个小时的时间完善了简历。下午两点半就接到蚂蚁的电话面试，当时我还在睡觉，看到是杭州来的电话瞬间睡意全无。<br>
                    蚂蚁：“段XX么，我是蚂蚁金服的，现在方面电话面试么”<br>
                    我:“啊，师兄能不能晚上下，我刚睡醒”</p>
                <p>蚂蚁：“晚上不行，要不改天”<br>
                    一听到“改天”就觉得大事不妙，算了，硬着头皮上吧</p>
                <p>蚂蚁：“师兄，等下，我穿下衣服”<br>
                    我：“好，我五分钟后再打给你”</p>
                <p>（五分钟后）<br>
                    蚂蚁:“自我介绍下”<br>
                    我：blablabla</p>
                <p>蚂蚁：“第三个项目是自己做的还是给老师做的？”<br>
                    我：blablabla</p>
                <p>蚂蚁：“从下面两个项目选择一个最满意的”<br>
                    我:我选择的是cord，意义非常大，但是真的不好展开呀，掉沟里了。 blablabla 蚂蚁：“说说dubbo的工作方式”</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">我：（不是很熟悉）就从最基本的dubbo+zookeeper说起，又说了容错机制 蚂蚁：“dubbo为什么会有这种容错机制”
蚂蚁&amp;我：因为场景需要吧
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li></ul></pre>
                <p>dubbo的容错机制有几种：<br>
                    1 可以快速失败然后报错<br>
                    2 也可以多次进行重试。</p>
                <p>蚂蚁：“openstack与docker的区别”<br>
                    我：blablabla</p>
                <p>OpenStack基于Linux的kvm虚拟机实现，配合qemu和libvirt完成虚拟化。</p>
                <p>docker类似Linux的LXC容器实现，使用cgroup隔离物理资源，使用namespace隔离进程。</p>
                <p>蚂蚁：“虚拟机启动流程”<br>
                    我： 回答的比较表层，说实在的，我也想知道底层是怎么实现的<br>
                    OpenStack的cinder，glance，neutron，nova搭配使用。</p>
                <p>首先通过master执行api，nova master中的nova sheduler会执行机器调度，找到合适的物理机，然后nova调用libvirt
                    的api启动kvm虚拟机，同时使用qemu虚拟化硬件设备，完成一台虚拟机的初始化。同时为其分配存储，安装镜像，以及配置网络信息等。<br>
                    蚂蚁：“说说你在cord项目组的作用”<br>
                    我： blablabla</p>
                <p>蚂蚁：“为什么这么晚投简历呀”<br>
                    我： 怕当炮灰</p>
                <p>蚂蚁：“你有什么问题要问的？”<br>
                    我： blablabla</p>
                <p>全程40分钟，全程紧张的不要不要的，全程尬聊，全程语无伦次，全程没有讨论到Java(我都怀疑我是不是应聘的Java工程)。<br>
                    蚂蚁简直就是神速，我还以为我第二天才会收到电面呢，没想到这么快。<br>
                    这位师兄很好，全程叫我不要紧张（我也没办法呀。。。）从最开始的给我五分钟穿衣服时间，我就认定这位小哥哥很nice。<br>
                    昨晚还刷了一个面经“https://www.nowcoder.com/discuss/69429?type=2&amp;order=1&amp;pos=8&amp;page=1”，结果我今天基础知识部分都没有问，小哥哥没按套路出牌呀（´Д`）
                </p>
                <p>作者：vec_<br>
                    链接：https://www.nowcoder.com/discuss/70025?type=2&amp;order=3&amp;pos=799&amp;page=1<br>
                    来源：牛客网</p>
                <p>之前过了个简单的简历面，过了几天后没打来以为凉了，然后昨晚又接到了电话，括号内容是回答说的，理解有限，不一定都对，欢迎纠正～加油每一个牛友们！</p>
                <p>阿里一面:<br>
                    1.学过哪些技术知识呢？</p>
                <p>2.说说接口和抽象类的区别(语法，设计，跨域三方面)<br>
                    1 成员<br>
                    2 用处（继承，实现）</p>
                <p>3.怎么判断两个对象是否相等？(名称和类加载器)<br>
                    全限定名和类加载器</p>
                <p>4.==和equals的区别(比较方式)</p>
                <p>5.排序算法有哪些呢(分类说，插入，选择，交换，归并，基排)</p>
                <p>5.堆排序的时间复杂度？怎么计算的(logn)</p>
                <p>6.说说归并的算法过程(先划分，归并，递归实现，把过程理清)</p>
                <p>7.知道先序，中序，后序遍历吗？(把算法过程说一遍)</p>
                <p>8.知道Java高并发相关知识吗？(并发包，把里面的内容介绍一边，介绍了闭锁，同步屏障，信号量的应用和底层实现:流控，线程执行顺序等)<br>
                    countdownlatch。<br>
                    cliderbarrier，samephere,</p>
                <p>9.谈谈JVM(从javac编译4阶段:词法，语法语义，生成，到类加载过程:双亲委派:加载，验证，准备，解析，实例化，实例化先谈堆分区，再说JVM内存结构，然后到GC,GC算法，触发条件，晋升，YGC,CMS过程实现，可达性分析等等，把整个体系说完后面试官肯定了一句说理解得不错…)
                </p>
                <p>1 编译成Java类，需要经过语法，词法分析，生成class字节码。</p>
                <p>2 jvm加载类，经过验证，解析，初始化等过程，先把类加载到方法区，再在堆中实例化一个Class对象。</p>
                <p>3 GC主要用于回收无用对象,GC年轻代满时触发ygc，晋升失败或者老年代满时触发full gc.</p>
                <p>4 年轻代停止复制，老年代标记清除。<br>
                    cms初始标记要stw，标记gc root（局部变量，本地内存的对象，静态变量等），然后并发标记，接着stopworld重新标记，<br>
                    最后并发清除，由于cms不整理，会有内存碎片。并且，cms是并发清除，吞吐量较低，但是保证延迟较低。</p>
                <p>g1进行内存分块，每块不一定有固定作用，把垃圾集中到一起，并且建立可预测的回收模型，同时可以控制停顿时间。</p>
                <p>10.做过哪些项目？用过哪些框架和技术呢？(SSH,M,Redis,Netty)</p>
                <p>11.看过spring 源码吗？(把容器启动过程说了一遍，xml解析，bean装载，bean缓存等)</p>
                <p>12.说说AOP实现原理(动态代理:jdk,cglib，分别用了哪些类或接口)</p>
                <p>13.事务的实现原理？(源码)</p>
                <p>14.说说四层网络模型(每层的协议及应用)</p>
                <p>15.谈谈tcp,udp的区别，分别有哪些应用(可靠，面向连接，首部)</p>
                <p>16.说说tcp三次握手过程？</p>
                <p>17.为什么是3次，2次可以吗？4次呢？(从失效的数据报谈2次为什么不行，从响应时间说为什么不用4次)</p>
                <p>18.你有什么想问我的？(问了分布式，负载均衡，缓存相关的，面试官回答说这些对校招是加分项，不懂也没关系，懂了的就更好，说校招关键还是基础，多看源码分析，多关注底层原理)</p>
                <p>19.面了50分钟左右</p>
                <p>作者：hfut小伙<br>
                    链接：https://www.nowcoder.com/discuss/69795?type=2&amp;order=3&amp;pos=823&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里一面（饭点打来的，准备去吃饭了，一个电话就过来了，40分钟左右）：<br>
                    上来简单的两分钟自我介绍，然后就问项目，然后我就巴拉巴拉说了项目大致干什么的，然后用到什么技术，说项目中用到了netty、zookeeper后，面试官就开始问了<br>
                    1、介绍下netty的线程模型？</p>
                <p>reactor线程模型，一个线程组负责接收请求和包装事件，然后把异步回调处理器注册到事件轮询器selector上，当epoll事件就绪时，另一个线程组负责调用回调方法完成io处理。</p>
                <p>2、IO流是怎么处理的？<br>
                    使用bytebuf缓冲进行处理，该缓冲支持零拷贝，可以复用header和body。</p>
                <p>3、netty里面boss线程池和work线程池是怎么交互？<br>
                    boss注册事件，通过事件队列，worker线程监听事件队列的事件，到达时取出事件执行即可。</p>
                <p>4、项目里面有分布式管理，分布式是怎么体现的？这个zookeeper是起什么作用？zookeeper如何管理服务器？<br>
                    多个服务分别部署。<br>
                    服务注册和发现中心，配置中心。<br>
                    zookeeper维护服务集群的配置信息，完成注册和发现，进行心跳检测。</p>
                <p>5、客户端怎么是如何找到服务器的？<br>
                    通过zk</p>
                <p>6、为什么选择netty，有没有和其他开源框架做过比较？<br>
                    mina</p>
                <p>然后就是一些细节问题了，项目也被批了一顿，后面就是基础知识了<br>
                    7、问我string源码阅读过不？简单的介绍一下string底层？<br>
                    final修饰的char数组，地址不能改变，但内容可变，只不过没有提供方法操作。</p>
                <p>8、string对象在JVM里面存储的位置？<br>
                    堆，以前可能在方法区的常量池</p>
                <p>9、object类有哪些方法，分别介绍一下？<br>
                    线程方法，finalize和clone。等略</p>
                <p>10、进程与线程的区别？</p>
                <p>11、线程池的概念，里面的参数，拒绝策略等等？</p>
                <p>12、悲观锁、乐观锁？</p>
                <p>13、synchronized和CAS？</p>
                <p>14、hashmap源码，着重讲了下put和get 的实现？</p>
                <p>15、做了一个算法题，两个有序数组，怎么合并？合并过程中时间复杂度和空间复杂度是多少？这个题我比较熟，很快就答出来了，他就把这个题升级了一下，说一个长度为100，一个为100万，合并的话，怎么才算最优的？也问了时间复杂度和空间复杂度？复杂度怎么计算的？
                </p>
                <p>1 归并，复杂度是On。</p>
                <p>2 算出两个数组总长度，然后从后往前，由于两个数组是有序的，当大数组的当前数字比小数组大，则直接放进去，如果比小数组小，则放小数组的数字，然后下标左移，然后依次类推，只需要一次扫描就可以放完。<br>
                    复杂度是0（n），空间复杂度也是on，n为大数组长度</p>
                <p>总体前面的项目问的东西比较多，问的基础知识还是很简单的，面试官人比较好，希望还有后面的面试，阿里，人生第一面啊。</p>
                <p>作者：敷衍、<br>
                    链接：https://www.nowcoder.com/discuss/69789?type=2&amp;order=3&amp;pos=826&amp;page=1<br>
                    来源：牛客网</p>
                <p>本人的第一次电话面前，阿里的面试官还是挺温和的，因为之前一点没准备，先介绍一下自己，然后问我 1.数组和链表的区别 、<br>
                    .知道hashmap吗<br>
                    3.sql注入知道吗<br>
                    4.http请求头部？<br>
                    5.session和cookie区别<br>
                    6.get post区别<br>
                    7.linux相关的知道吗 接下来就是项目 唉，记得住的就这些了。都不难，没好好准备，现在准备的很自信了没机会了，现在把握大一些了，怎么说一面至少过得去吧 最近看了一些东西给大家参考一下
                    Java基础，虚拟机， 内存分配，垃圾回收，锁，多线程，nio，hashmap，数据库存储引擎，索引。暂时这些关键字吧</p>
                <p>作者：我要去阿里<br>
                    链接：https://www.nowcoder.com/discuss/69644?type=2&amp;order=3&amp;pos=840&amp;page=1<br>
                    来源：牛客网</p>
                <p>/<em><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong>一面</strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></em>***********/<br>
                    1.设计原则和设计模式(简历第一条写的就是熟悉面向对象设计思想，坑了自己)，你用过哪些东西能体现这些设计原则；</p>
                <p>2.代理模式和装饰器模式有什么区别<br>
                    然而，实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy
                    class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模
                    式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">    我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。   
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>3.java io、nio，nio有哪些好处，io有哪些坏处；linux nio用什么函数实现，nio是同步还是异步<br>
                    epoll<br>
                    epoll的create,ctl，wait.<br>
                    对于轮询线程来说非阻塞的，对于底层的receive函数来说，它仍然是同步的阻塞操作。（unix网络编程）<br>
                    4.如何实现CPU上下文切换，那么有哪些函数导致线程切换</p>
                <p>进程切换<br>
                    进行进程切换就是从正在运行的进程中收回处理器，然后再使待运行进程来占用处理器。　这里所说的从某个进程收回处理器，实质上就是把进程存放在处理器
                    的寄存器中的中间数据找个地方存起来，从而把处理器的寄存器腾出来让其他进程使用。那么被中止运行进程的中间数据存在何处好呢？当然这个地方应该是进程的 私有堆栈。 　　<br>
                    让进程来占用处理器，实质上是把某个进程存放在私有堆栈中寄存器的数据（前一次本进程被中止时的中间数据）再恢复到处理器的寄存器中去，并把待运行进程的断点送入处理器的程序指针PC，于是待运行进程就开始被处理器运行了，也就是这个进程已经占有处理器的使用权了。
                </p>
                <p>yield，wait，sleep会导致线程切换。</p>
                <p>5.说说你知道的锁，乐观锁悲观锁</p>
                <p>6.atomicinteger如何实现，什么是CAS<br>
                    compareandset；</p>
                <p>7.reentrantlock的reentrant是什么意思<br>
                    可重入<br>
                    8.jvm内存分区</p>
                <p>9.垃圾回收器，CMS垃圾回收器相较于其他垃圾回收器有哪些优点<br>
                    优点：并发标记和清除，效率高，利用多核速率。<br>
                    缺点：不整理内存，导致碎片，且吞吐量不高。</p>
                <p>10.类加载器中方法有哪些，defineClass方法是啥<br>
                    findclass用于自己加载类，defineclass把byte流定义为一个类并加载。loadclass依据双亲委派加载，要破坏就要重写loadclass。</p>
                <p>11.jvm如何设置新生代、老年代大小，如何设置新生代8:1比例，jvm调优的方法，jvm内存是不是越大越好<br>
                    8:1:1。xmn和xmx，xms。两个相减就是老年代了。<br>
                    不是越大越好。<br>
                    调优方法：<br>
                    1确定指标，比如吞吐量，延迟，以及qps。</p>
                <p>2 压测，使用jmeter，loadrunner等工具压测，并且监控服务状态。比如visualvm。</p>
                <p>3 确定瓶颈，gc（gc日志，jstat）还是内存问题（jmap，mat等分析内存溢出和泄漏）。或者是代码问题（jstack定位线程，tprofier定位方法。）</p>
                <p>4 更改参数配置，内存更改配置，更换gc回收器，直到达到指标为之。</p>
                <p>12.分页查询，mysql索引实现<br>
                    limit 20，10</p>
                <p>13.了解http协议吗</p>
                <p>14.tcp三次握手，tcp长连接短连接</p>
                <p>15.MySQL数据库优化</p>
                <p>16.分析sql执行时间<br>
                    慢日志和explain</p>
                <p>17.spring 事务如何实现，哪些配置方式</p>
                <p>声明式事务，xml，注解，代码配置。aop的增强器实现</p>
                <p>18.用了spring的哪些东西，有什么好处</p>
                <p>19.linux文件结构</p>
                <p>1 inode节点保存除了文件名以外的所有信息，一个文件名指向一个inode，inode保存实际存储位置。<br>
                    2 目录也是一种文件，也指向一个inode，但是这个inode存的是文件名到inode的映射关系。</p>
                <p>硬链接指向同一个inode，软连接指向绝对路径<br>
                    20.CGLib如何实现<br>
                    代理类继承实现类，使用asm框架生成字节码，传入实际对象，代理类包含原实例方法和增强后的方法。<br>
                    /<strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong>二面</strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong>********************/<br>
                    1.实验室研究内容，给面试官讲明白（面试官说要看你对一个内容的了解程度，看你的潜力而不是现有知识的掌握）</p>
                <p>2.项目（我简历上没有项目，问我最近在做什么，关于这个扯了很久）</p>
                <p>3.知道哪些orm框架除了mybatis（不了解），mybatis实现（源码）</p>
                <p>3.mybatis事务，spring事务如何实现，本地事务，分布式事务</p>
                <p>4.spring你知道的都说一下，为啥不用spring boot，对新技术怎么看</p>
                <p>5.设计模式有哪些</p>
                <p>6.加密（越多越好，然而我只知道MD5），优缺点，MD5怎么破解，有没有想过加密的原理<br>
                    md5,sha,rsa</p>
                <p>7.java io，nio，aio，举例子</p>
                <p>8.jvm内存，如何定位jvm问题，如何优化，OOM<br>
                    四步走，压测+监控。工具排查，参数调优。</p>
                <p>9.哪些情况可能cpu 100%，如何解决<br>
                    代码出现死循环。<br>
                    并发量很多，cpu忙个不停。<br>
                    /*****<strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong><strong>重要</strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong></strong>/
                </p>
                <p>作者：凌风侠<br>
                    链接：https://www.nowcoder.com/discuss/69626?type=2&amp;order=3&amp;pos=843&amp;page=1<br>
                    来源：牛客网</p>
                <p>1.简单自我介绍一下</p>
                <p>2.项目（聊的比较多，主要描述自己负责的模块和某个功能的实现细节）</p>
                <p>3.JAVA数据结构（HashMap等底层原理）</p>
                <p>4.计算机网络:输入一个www.alibaba.com到加载整个页面经历的整个过程<br>
                    。<br>
                    5.数据结构:各种排序算法的时间复杂度（堆排序，归并排序，快排等），二叉树<br>
                    6.你未来的专业规划。<br>
                    7.你对新技术的了解，以及了解的途径。<br>
                    8.你还有什么要问我的</p>
                <p>作者：平行世界<br>
                    链接：https://www.nowcoder.com/discuss/69429?type=2&amp;order=3&amp;pos=865&amp;page=2<br>
                    来源：牛客网</p>
                <p>在牛客网上获取到很多知识和信息，现在反馈一波，希望能对广大找实习的同学有所帮助。<br>
                    个人情况：EE方向渣硕，二月末内推了阿里集团某部门Java岗，约三周完成了所有面试。</p>
                <p>面经如下：</p>
                <p>一面 （简历评估）：<br>
                    1、自我介绍</p>
                <p>2、TCP与UDP的区别</p>
                <p>3、TCP三次握手说一下（把流程说一遍，这里以为会继续问为什么不是两次或者四次，结果没有）</p>
                <p>4、看你项目用到线程池，说一下线程池工作原理，任务拒接策略有哪几种</p>
                <p>5、进程和线程的区别</p>
                <p>6、ArrayList与LinkedList的区别</p>
                <p>7、线程安全与非线程安全集合说一下，底层怎么实现的（hashmap，concurrenthashmap）</p>
                <p>8、Java内存模型，方法区存什么</p>
                <p>9、数据库事务隔离级别说一下</p>
                <p>10、synchronized和lock区别，可重入锁与非可重入锁的区别</p>
                <p>11、看你的项目用了悲观锁和乐观锁，说一下区别</p>
                <p>12、算法题：圆圈中最后剩下的数字<br>
                    使用余数法实现，也可以使用链表实现</p>
                <p>二面 （部门主管）：<br>
                    1、说一下Spring的IOC和AOP，底层什么原理</p>
                <p>2、动态代理有几种，Jdk与Cglib区别</p>
                <p>3、数据库三大范式</p>
                <p>4、左连接和右连接说一下，内连接呢</p>
                <p>5、数据库索引有几种</p>
                <p>6、数据库引擎你认识几种，innodb 和myisam 区别，你的项目用到哪个引擎</p>
                <p>7、若hashcode方法永远返回1会产生什么结果</p>
                <p>8、Error与RuntimeException的区别</p>
                <p>9、引用计数法与GC Root可达性分析法区别<br>
                    引用计数法为每个对象的引用计数，可能导致循环引用时对象无法释放。<br>
                    10、双亲委派机制说一下</p>
                <p>11、算法题：找出一个数组中第100个小的数字（堆思想解决）</p>
                <p>三面&amp;四面 （这里合在一起写了，分别是部门A总监与B总监，本以为三面完了就是HR面，结果隔天B总监打过来说补一轮技术面~~三面和四面更多的是问项目，基础问得不多）：<br>
                    1、volatile关键字作用<br>
                    可见性和原子性</p>
                <p>2、看你项目用到策略模式和工厂模式，说一下区别<br>
                    策略模式可以配合策略实例。<br>
                    工厂模式用于获取实例。</p>
                <p>3、模板方法模式</p>
                <p>模板方法就是一个抽象类模板，规定好了一个方法执行模板，里面有抽象方法或实际方法，并且有部分抽象方法需要自己实现。</p>
                <p>4、开闭原则懂吗，说一下</p>
                <p>不要修改源代码，而是通过继承，组合等方式来复用代码</p>
                <p>5、NIO说一下你的理解</p>
                <p>IO多路复用</p>
                <p>6、AtomicInteger底层原理</p>
                <p>cas</p>
                <p>7、CAS机制会出现什么问题</p>
                <p>1 ABA问题<br>
                    可以通过版本号来解决。</p>
                <p>2 循环时间长开销大<br>
                    如果jvm支持pause系统指令，可以提高效率</p>
                <p>3 只能保证单个变量的原子操作<br>
                    AtomicReference类型可以保证一个引用的操作是原子性的，从而可以保证引用对象内部的变量也是原子性操作。</p>
                <p>8、还用过并发包哪些类</p>
                <p>9、你实习的本地缓存过期策略怎么设置，一致性怎么保证<br>
                    linkedhashmap，过期可以lru或者时间过期</p>
                <p>10、分布式理论懂多少，说一下（这里我说了CAP，Base，paxos）<br>
                    1 cap，base</p>
                <p>2 一致性协议2pc，3pc。paxos ，raft，zab。</p>
                <p>3 分布式事务及事务消息。分布式锁实现，分布式全局id生成器，负载均衡，数据库的分库分表。</p>
                <p>4 分布式session，分布式缓存，分布式数据库hbase，消息队列kafka。</p>
                <p>5 分布式服务，微服务，容器和k8s调度系统。</p>
                <p>6 分布式计算平台 Hadoop，其中的分布式文件系统hdfs，分布式计算框架mr，spark和storm，调度系统yarn。</p>
                <p>11、分布式事务有了解吗</p>
                <p>理论：2pc，3pc<br>
                    实践：TCC，rocketmq事务消息，自己实现事务消息</p>
                <p>12、RabbitMQ消息队列丢失消息，重复消费问题</p>
                <p>不断重发。<br>
                    消息记录</p>
                <p>五面（交叉面，蚂蚁金服的面试官，别问我怎么知道的，说来话长<s>简短的20分钟，没问多少就挂电话了，貌似凉凉</s>）<br>
                    1、学习成绩</p>
                <p>2、有参加过算法比赛吗</p>
                <p>3，Redis和memcached</p>
                <p>redis的数据结构更丰富，并且有分布式方案，支持持久化</p>
                <p>4、Redis集群宕机，数据迁移问题</p>
                <p>rdb全量备份+aof增量备份，设定间隔为一秒，大部分数据已经备份完成。</p>
                <p>redis数据迁移操作步骤<br>
                    先使用redis客户端连接命令,分别连接旧环境中的主从redis<br>
                    Src目录下./redis-cli -h IP -p PORT<br>
                    使用info replication 命令找出主redis<br>
                    使用客户端命令连接主redis 之后,执行 BGSAVE 命令,会返回 Background saving started (保存redis中最新的key值)<br>
                    然后执行LASTSAVE 命令 ,会返回一个时间戳 (返回最近一次 Redis 成功将数据保存到磁盘上的时间，以 UNIX 时间戳格式表示),检查主redis
                    src目录下的dump.rdb生成时间,与当前时间相同.<br>
                    关闭客户端,进入主redis的src目录下,拷贝此目录下的dump.rdb 文件<br>
                    将拷贝的dump.rdb文件替换新环境下 src目录下的配置文件<br>
                    启动新环境的redis ,完成数据迁移</p>
                <p>5、看你项目用到Spring boot，那有用过Spring cloud吗</p>
                <p>没有。springcloud提供更加多的微服务支持。而dubbo主要专注于服务治理，而不像springcloud主要是构建生态。<br>
                    当然dubbo提供了扩展点让使用者来实现这些扩展功能。</p>
                <p>6、RPC说一下</p>
                <p>rpc一般基于tcp协议实现，自己构建上层协议，比如dubbo，hession，同时使用不同的序列化协议比如thirft，protobuf等。</p>
                <p>而基于tcp的编程则使用netty完成，一来是可以使用NIO的io复用机制达到优秀性能，而来使用netty编程简化了代码，以及提供了更好的扩展性。</p>
                <p>7、说一下你对微服务的理解，与SOA的区别</p>
                <p>微服务就是把soa服务更加细粒度的拆分，独立部署，快速迭代，功能独立。<br>
                    微服务框架一般需要包含：<br>
                    1 同时具备服务网关，负载均衡的功能。<br>
                    2 服务快速部署和支持伸缩，服务注册与发现，服务配置统一管理。<br>
                    3 心跳机制，容错机制。<br>
                    4 熔断，限流等特性保证一个服务宕机不会影响整体服务。<br>
                    5 服务监控，服务的链路跟踪检测，保证能够快速定位问题所在环节。<br>
                    6 服务灰度发布，服务的降级<br>
                    7 另外还可能包括任务调度功能，类似k8s的提供。</p>
                <p>六面（HR面）<br>
                    1、平常怎么学习的</p>
                <p>1最早是视频<br>
                    2后来主要是看书<br>
                    3然后开始看一些博客和社区<br>
                    4接着自己写一些博客，demo。</p>
                <p>2、兴趣爱好<br>
                    运动，健身，旅游。</p>
                <p>3、觉得自己前面几轮面试怎么样<br>
                    还可以吧</p>
                <p>4、除了Java还研究过其它什么技术（我说AI，区块链）</p>
                <p>分布式理论。</p>
                <p>大数据，云计算。</p>
                <p>5、跟我介绍一下区块链~</p>
                <p>捞</p>
                <p>6、怎么看待国内区块链的发展</p>
                <p>7，跟我说一下你认为最具有挑战性的项目</p>
                <p>网易那个吧</p>
                <p>8、问我还参加了什么公司的招聘</p>
                <p>京东，百度</p>
                <p>9、如果有网易游戏，腾讯，阿里的offer你会选择哪个</p>
                <p>看部门和岗位情况，具体城市等。因为阿里是Java系，会倾向选择阿里。</p>
                <p>10、英语10分钟交流（瞬间懵了，这里估计是部门有英语交流要求）</p>
                <p>面经如上，有一些问题确实想不起来了，请谅解。<br>
                    总体来说面试难度没有我在其它大佬们的帖子看到的这么难，都是基础加项目，另外也可能是因为我的心态一直比较好，所以面试发挥还算OK吧~<br>
                    HR说面试结果会在4月份中旬出来，估计是进备胎池了，慢慢等吧，继续复习，准备其他公司招聘。</p>
                <p>有后续会继续更新~</p>
                <p>作者：NULL170<br>
                    链接：https://www.nowcoder.com/discuss/69206?type=2&amp;order=3&amp;pos=885&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里一二面面经<br>
                    一面大约是3月6、7号的样子，人生第一次面试（电面）<br>
                    说实话很紧张</p>
                <p>关于项目：简单的问了问，然后问我高并发怎么优化，这方面不会啊<br>
                    然后问我了解HashMap么</p>
                <p>接下来我就使劲儿，说了一下HashMap还有ConcurrentMap区别和各自的实现，感觉说了好久</p>
                <p>面试官问我了解JVM么，可是他都不提问，就让我一直说，一直说</p>
                <p>从各个分区的特点，各个回收机制，还有各个垃圾回收器的特点 balabala还有很多 然后高潮来了</p>
                <p>我一个人说很尴尬啊 我轻轻对着手机说了一声 喂？ 面试官说 我在呢 你说吧 （贼尴尬）</p>
                <p>乐观锁和悲观锁了解么，还有Lock和Sycrounized的区别（因为这块还没复习，没说上来，接下来的几天把各个锁复习了一下，终于可以跟美团面试官谈笑风声 哈哈哈 我在搞笑啦 菜死了）</p>
                <p>怎么解决秒杀，瞎说的，不太会<br>
                    1前端页面控制，请求过滤。<br>
                    2 服务负载均衡，集群部署服务，消息队列削峰，使用缓存处理一部分请求，最后再到达数据库。</p>
                <p>Spring事务管理 说了一下但是说的不好</p>
                <p>声明式事务，配置匹配式以及对应的事务传播机制。</p>
                <p>声明增强器advisor。通过动态代理实现到对应的方法中。</p>
                <p>传播机制，required就是需要开启事务，never就是不用事务，support是支持事务但是不一定需要，如果有的话就在事务上下文中运行。</p>
                <p>Spring IOC 和AOP 这个感觉都问呢</p>
                <p>有啥想问他的么</p>
                <p>一面大概一个小时</p>
                <p>二面<br>
                    这个真得各位牛友的借鉴意义不大<br>
                    面的我这个菜鸡心寒，一面隔天就打来电话了，两面的面试官都奇迹的让我放了鸽子，就是没接到电话，说实话阿里面试官真不错，要是我我都生气了。<br>
                    二面面试官全程项目<br>
                    为什么这么做，怎么实现的，为什么这么实现，看我说一种，觉得是不是更好。。</p>
                <p>我感觉到了被蹂躏的快感，问了前缀树的实现，问正则表达式的时间复杂度，呵，我以为自动机会回退，竟然说了个n方，就很难受。</p>
                <p>正则表达式就是一个自动机，复杂度为O（n）<br>
                    就是各种项目扣细节，我面试完好好的把项目琢磨了个通透，就是讲的一定要让人听懂。</p>
                <p>面试官人还是不错的，面试完又聊了很久家常啥的，后来加了微信让我帮他拉人内推</p>
                <p>二面足足一小时二十分钟<br>
                    刚挂了电话就是美团一面 一下午手都麻了 别问我为啥不用耳机 耳机坏了</p>
                <p>ps：二面以后，我也不知道凉没凉，问了面试官说三面可能性大 ，等了一周了又去问，说是下周有希望，感觉可能是个备胎吧，就这感觉</p>
                <p>作者：悲伤的小橙子<br>
                    链接：https://www.nowcoder.com/discuss/69171?type=2&amp;order=3&amp;pos=890&amp;page=1<br>
                    来源：牛客网</p>
                <p>楼主3月9号找人内推哒，3月14号一面，3月16号二面，没做在线测评和编程，发出来面经攒一波人品～</p>
                <p>嗯，楼主渣硕(╥_╥)，现在在美团实习，背景。</p>
                <p>一面:<br>
                    1.实习项目</p>
                <p>结合项目问了幂等，消息队列的一些实现</p>
                <p>幂等性实现：对于http rest api来说，幂等性就是保证四个方法的幂等性。</p>
                <p>消息队列实现：<br>
                    1 rpc的实现（协议，序列化，网络编程，服务治理）<br>
                    2 数据持久化。<br>
                    3 zk维护消费关系，维护配置和心跳。<br>
                    4 消费确认，消息有序，消息不重复的问题解决<br>
                    5 kafka的存储是分布式的，消费者可以是单播和广播。<br>
                    6 推拉模式的区别。</p>
                <p>2.悲观锁和乐观锁的原理和应用场景</p>
                <p>读多写少。<br>
                    写并发量大。</p>
                <p>3.mysql行锁实现</p>
                <p>索引加锁</p>
                <p>4.多线程有没有实践过</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">结合项目说了线程池和callable future
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>5.volatile底层原理</p>
                <p>6.concurrenthashmap原理</p>
                <p>7.hashmap初试容量</p>
                <p>8.linkedlist&amp;arraylist</p>
                <p>9.一个在线编程</p>
                <p>负载均衡的一个实现，服务器资源分配70% 20% 10% 反正我只会写轮巡，还有bug，我要哭死了。。</p>
                <p>加权轮询算法。<br>
                    1 做一个权值到ip映射的map<br>
                    2 权值的比例根据服务器资源分配来安排。写成数组[1,1,1,1,1,1,1,2,2,3]<br>
                    3 然后轮询</p>
                <p>一面问问题20分钟 磨洋工写代码，写完了面试官不见了，我在电脑前尬坐了30分钟，才发现有聊天功能可以跟面试官说话，他开会开了静音，好尴尬啊。。</p>
                <p>二面:<br>
                    1.自我介绍</p>
                <p>2.作为一个女生有什么职业规划？你看很多学计算机的女生都转行了（黑人问号）</p>
                <p>3.hashmap原理</p>
                <p>4.事务的特性及理解</p>
                <p>5.实现一个LRU缓存（楼主忘了linkedhashmap怎么做了，只记得o（n）的方法，?）<br>
                    重写removelast方法，然后返回值是size &gt;cachesize，当超过size时就会被替换了。并且替换的是链表头，也就是lru。</p>
                <p>也可以使用超时替换机制，让节点带有时间戳，然后通过轮询线程判断时间是否超时，然后进行删除。</p>
                <p>如果要自己实现了lhm，则需要重新写一个hashmap。再写一个链表把节点串起来。<br>
                    6.设计模式用过吗？<br>
                    结合项目说了工厂和职责链，又问了单例和单例构造函数的注意点<br>
                    工厂生成实例。职责链则可以让请求自动走完链条，复用了职责链，并且方便扩展操作。</p>
                <p>7.在线编程<br>
                    两个有序数组的合并，就写了常见的归并排序。。</p>
                <p>二面也是问问题20分钟加编程20分钟，最后面试官提醒我找一下bug，然后就结束了。。</p>
                <p>总的来说我的面试为啥这么简单&amp;&amp;每次都要写代码呢。。哭，感觉要没戏了，大家看看就好~</p>
                <p>作者：wuliji<br>
                    链接：https://www.nowcoder.com/discuss/69032?type=2&amp;order=3&amp;pos=902&amp;page=1<br>
                    来源：牛客网</p>
                <p>0.自我介绍和技能栈，平时怎么学习的</p>
                <p>1.说说快排和归并。</p>
                <p>2.快排为什么快。（突然脑子懵了）</p>
                <p>3.从数据库中主键字段取出上万条数据，用哪种排序好？<br>
                    主键排序。</p>
                <p>4.TCP/IP协议，为什么TCP是可靠传输，为什么不是4，5次握手？<br>
                    滑动窗口</p>
                <p>5.HashMap底层，put，get详细过程，如果重写equals不重写hashcode会怎么样？</p>
                <p>7.B+树介绍，红黑树介绍，B+为什么适合做数据库索引</p>
                <p>8.ArrayList和LinkedList，适用场景</p>
                <p>9.具体说说JVM内存模型，GC回收算法，可达性分析。</p>
                <p>10.给一个数，快速判断是否为2的N次幂。（想了半天最后还是没弄出来）</p>
                <p>神仙题<br>
                    最快速的方法：<br>
                    (number &amp; number - 1) == 0</p>
                <p>11.你有什么想问的吗？（我问了那边现在主要做的业务）</p>
                <p>业务，技术栈</p>
                <p>首先感谢阿里给的面试机会（其他的简历都泡水两周了），投的是菜鸟java岗，第一次面试紧张，口齿不是很清，面试官耐心引导，非常nice，大家一起加油吧。</p>
                <p>作者：NotObject<br>
                    链接：https://www.nowcoder.com/discuss/68950?type=2&amp;order=3&amp;pos=916&amp;page=1<br>
                    来源：牛客网</p>
                <p>—阿里巴巴一面(37分钟)<br>
                    没有让我自我介绍,直接进入了正题</p>
                <ol>
                    <li>
                        <p>对面向对象的理解</p>
                    </li>
                    <li>
                        <p>面向对象为我们编程带来了什么好处</p>
                    </li>
                    <li>
                        <p>对封装,多态,继承的理解</p>
                    </li>
                    <li>
                        <p>Java中哪些集合是线程安全的?哪些是线程不安全的</p>
                    </li>
                    <li>
                        <p>如果A类要访问B类中的字段,要怎么去设计<br>
                            1 继承可以访问非私有字段</p>
                    </li>
                </ol>
                <p>2 引入实例可以访问非静态非保护字段。</p>
                <p>3 通过反射可以访问全部字段。</p>
                <ol start="6">
                    <li>在多线程中,A类有一个静态成员变量,如果A类在运行期间修改了它,B类是否能知道</li>
                </ol>
                <p>可以。静态变量存在运行时常量池，也就是方法区中。</p>
                <ol start="7">
                    <li>
                        <p>在多线程程序中,怎么保证线程安全</p>
                    </li>
                    <li>
                        <p>Exception,Error和Throwable的异同<br>
                            前两个继承自后者，需要实现构造方法，并且继承后者的方法。</p>
                    </li>
                    <li>
                        <p>在什么情况下会触发Full GC<br>
                            0 system.gc方法可能会触发</p>
                    </li>
                </ol>
                <p>1 大对象和数组分配失败，老年代空间不足。</p>
                <p>2 永久代内存不足。</p>
                <p>3 cms的晋升失败和并发分配失败。</p>
                <p>4 统计minor gc晋升大小超过了老年代空间</p>
                <ol start="10">
                    <li>
                        <p>在什么情况下新生代中的对象会被移动到老年代(永久代)<br>
                            大对象，晋升</p>
                    </li>
                    <li>
                        <p>在使用Mysql时是否自己建立过索引(我回答没有)</p>
                    </li>
                </ol>
                <p>create index on列名、默认聚簇索引，使用客户端工具。<br>
                    12. 那分别给我介绍下数据库中聚簇索引和非聚簇索引</p>
                <ol start="13">
                    <li>在一个系统中,如何去做整个Exception的设计?<br>
                        需要设计层级，最高层的exception，然后设计子exception，这样高层可以捕捉底层错误，或者底层封装错误抛给高层。</li>
                </ol>
                <p>并且高层exception要继承exception或runtimeexception，后者一旦发生程序就会中断。。</p>
                <p>定义异常：<br>
                    必须是自定义类继承Exception。</p>
                <p>继承Exception原因：<br>
                    异常体系有一个特点：因为异常类和异常对象都需要被抛出。<br>
                    他们都具备可抛性。这个可抛性是Throwable这个体系中的独有特点。<br>
                    只有这个体系中的类和对象才可以被throws和throw操作。</p>
                <p>throws和throw的区别：<br>
                    throws使用在函数上。<br>
                    throw使用在函数内。</p>
                <p>throws后面跟异常类，可以跟多个，用逗号隔开。<br>
                    throw后面跟异常对象。</p>
                <p>自定义异常时：如果该异常的发生无法继续运行下去<br>
                    就让自定义异常继承RuntimeException</p>
                <p>对于异常分两种：<br>
                    1.编译时被检测的异常—&gt;要么继续抛，要么try<br>
                    2.编译时不被检测的异常(运行时异常。RuntimeException以及其之类)—&gt;里面抛，外面不用声明。—&gt;程序停止<br>
                    */</p>
                <ol start="14">
                    <li>在系统设计中,如果我对某种类型的Exception感兴趣,设计一个方案,使我能够对其进行监控</li>
                </ol>
                <p>另外总结一下运行时异常与非运行时异常的区别：<br>
                    运行时异常是RuntimeException类及其子类的异常，是非受检异常，如NullPointerException、IndexOutOfBoundsException等。由于这类异常要么是系统异常，无法处理，如网络问题；<br>
                    要么是程序逻辑错误，如空指针异常；JVM必须停止运行以改正这种错误，所以运行时异常可以不进行处理（捕获或向上抛出，当然也可以处理），而由JVM自行处理。Java
                    Runtime会自动catch到程序throw的RuntimeException，然后停止线程，打印异常。<br>
                    非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类，是受检异常。非运行时异常必须进行处理（捕获或向上抛出），如果不处理，程序将出现编译错误。一般情况下，API中写了throws的Exception都不是RuntimeException。
                </p>
                <p>1 捕捉特定类型exception并且记录日志。<br>
                    2 监控实例</p>
                <ol start="15">
                    <li>在分布式系统中,设计一个方案来保证集群中每台服务器所生成的订单ID不会重复?</li>
                </ol>
                <p>全局id，单实例：时间戳，uuid，自增id<br>
                    分布式: redis id和zk id。</p>
                <ol start="16">
                    <li>你有什么想问我的(都是泪,脑袋抽了下,问了两个奇葩问题…)</li>
                </ol>
                <p>还有下面两题之前没记起来:</p>
                <ol>
                    <li>
                        <p>在Servlet中一个请求到响应的整个执行过程<br>
                            servlet实例化，生成调用链，tomcat的请求connector和container，http请求包装，然后经过调用链，直到servlet，执行service方法，</p>
                    </li>
                    <li>
                        <p>具体怎么实现一个Filter<br>
                            filter就是责任链，可以用链表或者队列实现。</p>
                    </li>
                </ol>
                <p>作者：IChp<br>
                    链接：https://www.nowcoder.com/discuss/68870?type=2&amp;order=3&amp;pos=930&amp;page=1<br>
                    来源：牛客网</p>
                <p>二面<br>
                    面试官问了我之前做的一个项目（安卓的），然后让我思考有什么不足之类的，脑子很懵，语无伦次，确实很多东西没有思考过，然后就凉凉了，但是面试官超级好，给我上了一课啊不亏哈哈哈，帮面试官宣传下</p>
                <p>只要同学提供：姓名、手机号、邮箱和求职岗位就可以获得面试机会。<br>
                    以上信息可以发给：xueming.yxm@alibaba-inc.com, 13777850768<br>
                    不能来实习的同学，我们可以直通秋招，拿直通卡；如果只能来实习不到一个月，我们有2周mini实习。对于观望的同学，可以先投递简历锁定，准备好再面试，预留给同学足够的时间。这边的部门提供Java工程师，测试工程师，算法工程师。（业务平台事业部）
                </p>
                <p>====================================================================================================================================<br>
                    一面<br>
                    自我介绍，怎么学java的。</p>
                <p>1.Object有哪些方法</p>
                <p>2.你刚说的clone浅复制和深复制有什么区别，举个例子</p>
                <p>深拷贝会复制实例内的成员变量对应的对象，浅拷贝只会只会拷贝引用，指向同一个对象<br>
                    3.equals如果不重写hashCode会怎样，举个例子，equals默认情况下是返回什么</p>
                <p>4.容器了解吗，说下</p>
                <p>5.hashMap的put方法说下，它是安全的嘛，举个例子，多线程同时put会有什么问题</p>
                <p>6.怎么让他安全呢（我说了table,synchroniedMap,concurrentHashMap）,说下他们三个的区别</p>
                <p>7.concurrentHashMap原理</p>
                <p>8.内存泄漏，怎么防止，localThread</p>
                <p>静态容器，连接池，监听器等组件。<br>
                    9.wait和sleep区别</p>
                <p>10.wait应用场景</p>
                <p>11.并发包下面用过哪些，我说闭锁栅栏和信号量，分别说说</p>
                <p>12.消费者生产者模式怎么设计的，如果中间一个篮子只能放一个苹果，生产者和消费者各只有一个，怎么设计，如果很多线程又怎么设计</p>
                <p>13.死锁什么情况下会出现，举个例子，怎么预防呢<br>
                    A,B加锁后同时请求对方的锁</p>
                <p>14.A和B相互转账可能会发生死锁，设计程序避免这种情况<br>
                    不要用悲观锁，改用MVCC机制，当事务冲突时进行回滚</p>
                <p>15.说下常见的数据结构</p>
                <p>16.栈和链表的区别，你自己怎么设计一个栈，栈用在什么地方，举个例子</p>
                <p>17.volatile说下用处，举个例子</p>
                <p>18.有哪些排序算法，说下冒泡和选择</p>
                <p>19.tcpip http https分别说下，https怎么做到安全的</p>
                <p>20.数据库一张表，有学生姓名，成绩，课程名，找到所有成绩大于80的学生</p>
                <p>21.说下数据库的设计思想</p>
                <p>22.JVM分区，分别干什么用的</p>
                <p>23.String s = new String(“abc”);在上面的分区中怎么玩的</p>
                <p>24.说下垃圾回收机制，分代区域怎么分的</p>
                <p>25.你的图书管理系统登录模块怎么实现的</p>
                <p>26.如何识别是同一个用户</p>
                <p>27.session机制</p>
                <p>28.用户登录密码加密</p>
                <p>29.一个反射机制写个工具类扫描一个包下面的类方法什么的是否符合java编写规范<br>
                    不符合</p>
                <p>30.ArrayList和LinkedList的区别</p>
                <p>作者：世幻<br>
                    链接：https://www.nowcoder.com/discuss/68849?type=2&amp;order=3&amp;pos=931&amp;page=1<br>
                    来源：牛客网</p>
                <p>0.专业，毕业时间<br>
                    1.自我介绍</p>
                <p>2.数组和链表有什么区别</p>
                <p>3.map，set，stack（太紧张了没听清）</p>
                <p>4.hashmap读场景特别多，写场景比较少，改变策略</p>
                <p>5.内存泄漏，如何定位排查<br>
                    dump分析。gc频繁，老年代剩余空间不足等情况。visualvm监控内存使用情况。</p>
                <p>6.死锁</p>
                <p>互斥，循环依赖，不可剥夺，请求和保持对对方资源的请求</p>
                <p>预防 资源分配图，有序分配资源</p>
                <p>避免 银行家算法</p>
                <p>检测和解除 通过资源分配图检测死锁，通过抢占，回滚，杀死进程来进行死锁恢复</p>
                <p>7.除了java还学过哪些东西</p>
                <p>8.问项目</p>
                <p>9.有没有参加过编程类竞赛（没有）</p>
                <p>10.实习时间可以保证不</p>
                <p>11.有一份ip地址和地理位置的缓存（写一个方法）从内存和效率上考虑<br>
                    （目测已凉，人生中第一次面试太紧张了）</p>
                <p>linkhashmap，或者用zset这样的跳表+hash的结果</p>
                <p>作者：crud都不会的渣渣<br>
                    链接：https://www.nowcoder.com/discuss/68835?type=2&amp;order=3&amp;pos=933&amp;page=1<br>
                    来源：牛客网</p>
                <p>没想到进二面了，总感觉面试比其他大佬简单多了，算法题一题也没问，感觉很奇怪，具体问题就不发了，都是别人面经里面的，就是框架，虚拟机，反射，nio，rpc，设计模式，二进制数据协议？不了解，22分钟，时间也很短，让我多看看一些开源技术的源码
                </p>
                <p>作者：striveliuliu<br>
                    链接：https://www.nowcoder.com/discuss/68785?type=2&amp;order=3&amp;pos=938&amp;page=1<br>
                    来源：牛客网</p>
                <p>一面 简历评估（10分钟）<br>
                    面试官主要问了一些简历上边的实习时候做的项目，让我简单的介绍一下自己的项目。同时问做的什么研究，由于我大方向是网络方向，实验室的主要研究方向是分布式存储，分布式计算。可能面试官对于分布式不是很熟悉，这一部分我提了一下，就没再多问分布式的东西。
                </p>
                <p>面试官打来电话的时候，正在外面跟同学玩，就很诚实的跟面试官说了，面试官也听到我的环境有点嘈杂，可能就不想多问了吧，就说很简短的介绍一下就好了，别的也就没多问。<br>
                    二面 （50分钟）<br>
                    二面是晚上10点钟左右打过来的，首先要我介绍自己所做的项目，我就介绍了实习的时候作为项目组长做的两个项目，一方面比较熟悉，另一方面也可以体现自己的研究方向。</p>
                <p>第一个项目是做大数据存储和检索的，主要问了大规模数据的存储，如何实现数据的存储，同时是如何设计关系模式的，使用的分布式架构是什么，具体的实现原理是什么。</p>
                <p>关于检索方面，具体问了我如何实现的全文检索，以及如何实现数据的索引建立，以及如何实现特定名词的检索。然后就是第二个项目，这个比较简单，主要是做了一个web项目，也参与了部分前端的开发，问了服务端的实现springMVC。
                </p>
                <p>项目问完以后，就问一些基本的基础知识，计算机网络方面，问了TCP协议的三次握手和四次挥手，以及网络中数据包是如何传输的，同时问了当浏览器中输入一个url以后，后台的操作是什么样的，如何通过http协议获取网络资源的。
                </p>
                <p>后边主要问了数据库方面的问题，数据库的索引如何建立，数据库的存储引擎是怎么样的。操作系统方面问了进程和线程，进程与线程的区别以及如何实现同步，问了实现同步的方法，又问了synchronize，lock的区别，以及wait,notify等的区别。最后问了堆和栈的区别。
                </p>
                <p>还有部分数据结构和算法的东西，hashmap的实现原理，以及ConcurrentHashMap如何实现并发控制的。<br>
                    编程测试（两道题）<br>
                    第一题实现快速排序，第二题是实现一个同步控制，使用多线程打印abcabcabc<br>
                    三面（20分钟）<br>
                    首先自我介绍，然后看我的简历，发现我从2015年开始一直在实习，问了很多关于实习中的事情，问我实习的感受和收获等。然后就问我什么时候能够实习，实习期能够多久，实习时间不能保证的话就不容易出成果，问我还想要实习吗，意思就是如果你不能保证两个月以上的实习时间就别来了，这样比较浪费资源。
                </p>
                <p>然后就问了一些关于网络底层方面的知识，因为自己有一个项目涉及到底层网络拓扑的部署，以及网络故障的检测。主要就问了一些网络中如何检测故障，由于做的是一个web自自适应网络拓扑构建，网页中网络拓扑矢量图自己如何实现自由拖动，并且展示动态效果的，如何动态探测到网络故障并实时显示的。<br>
                    四面（交叉）15分钟<br>
                    由于我的毕设是做SDN相关的，面试官也是做sdn的，就问了SDN网络与传统网络的区别，以及SDN网络中如何实现相应的优化和效率的提升等问题，以及我的毕设论文如何实现SDN网络资源的编排和管理。</p>
                <p>同时提到了实验室的研究方向，分布式相关的，我就说自己做的的SDN论文需要结合一些分布式相关的研究来实现整个SDN控制器的分布式处理。由于提到了分布式，面试官让我介绍一些自己目前分布式方面做的东西，主要讲了一个分布式数据库，是我一个项目中做的，怎么做分库分表。
                </p>
                <p>另一个是分布式文件系统，主要是项目中用来做底层文件存储的，怎么做文件的分布存储以及容错、一致性方面的问题。</p>
                <p>由于我提到了多副本状态机，从而保证分布式一致性，面试官顺道就问了分布式存储中的一致性问题，让我详细讲一下raft算法，以及paxos与raft算法的区别。最后让我讲了目前项目中遇到的一个最难的挑战是什么，是怎么解决的。<br>
                    Raft协议比paxos的优点是 容易理解，容易实现。它强化了leader的地位，把整个协议可以清楚的分割成两个部分，并利用日志的连续性做了一些简化：<br>
                    （1）Leader在时。由Leader向Follower同步日志<br>
                    （2）Leader挂掉了，选一个新Leader，Leader选举算法。</p>
                <p>raft优势：简单，好懂，易实现。<br>
                    场景没什么太大区别.</p>
                <p>作者：诗酒趁年华0819<br>
                    链接：https://www.nowcoder.com/discuss/68750?type=2&amp;order=3&amp;pos=942&amp;page=1<br>
                    来源：牛客网</p>
                <p>首先是30分钟以内的在线编程题，题目不难，需要在最短的时间想出最多的解法，并且说出时间复杂度</p>
                <p>然后开始问技术<br>
                    1.垃圾回收机制</p>
                <p>2.事务的四个属性</p>
                <p>3.HashMap和HashTable的区别</p>
                <p>4.StringBuffer和StringBuilder的区别</p>
                <p>5.服务器性能调优</p>
                <p>6.Spring AOP</p>
                <p>7.Mybatis和Hibernate的区别</p>
                <p>8.手写程序造成程序抛内存泄露的异常</p>
                <p>9.高并发处理</p>
                <p>面试持续1小时15分钟<br>
                    面试官脾气温和，给我很多启发<br>
                    题目只答出来了表层，他往深了问，问我为什么要这么设计的时候蒙圈了，程序设计题也只想出一种解法，思路不开阔<br>
                    目测凉凉了……</p>
                <p>作者：crud都不会的渣渣<br>
                    链接：https://www.nowcoder.com/discuss/68699?type=2&amp;order=3&amp;pos=951&amp;page=1<br>
                    来源：牛客网</p>
                <p>1.什么点往南走1公里，往东走1公里，往北走。。。回到原点。</p>
                <p>2.8个球，一个轻，天平2次找出来。</p>
                <p>1 先拿6个球称一次，找出轻的三个，如果一样重，则称另外两个。</p>
                <p>2 轻的三个中任取两个比，如果两个一样重，则轻的是第三个，如果不一样重，轻的就是那个了。</p>
                <p>3.stringbuffer和stringbuilder</p>
                <p>4.hashmap，hash冲突，并发下会造成什么问题</p>
                <p>5.hashset怎么保证唯一性<br>
                    如果key存在就会替换，所以唯一性，</p>
                <p>6.介绍concurrenthashmap</p>
                <p>7.synchronize和reentrelock区别</p>
                <p>8.线程池那些参数，拒绝策略<br>
                    9.start方法和run方法区别<br>
                    10.公平锁和非公平锁<br>
                    11.http1.1和1.1和2.0区别<br>
                    1header<br>
                    2长连接<br>
                    3 支持二进制数据body<br>
                    12.数据库乐观锁悲观锁</p>
                <p>13.线程进程协程</p>
                <p>协程自带上下文。不需要切换cpu。<br>
                    所以自然是协程比多线程切换要快。</p>
                <p>但是要利用多核cpu。还是得靠多线程来实现，因为协程是用户态的东西，内核线程则是内核态的东西，支持并行。<br>
                    所以一般使用多线程+协程的方式实现。</p>
                <p>14.反射能取到一个变量的名字吗 差不多就记得那么多25分钟，第一次面大公司啊。。</p>
                <p>不能，只能取到类型。</p>
                <p>作者：nefur_右边<br>
                    链接：https://www.nowcoder.com/discuss/68594?type=2&amp;order=3&amp;pos=956&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里一面<br>
                    开始时间：2018-03-10 16 : 47<br>
                    持续时间：31 m 1 s</p>
                <p>面试开始：<br>
                    痛苦，不想多说。阿里不愧是阿里，问的很有深度，而且都围绕着项目来。</p>
                <p>面试题目：<br>
                    自我介绍，巴拉巴拉大概四五分钟。<br>
                    开题让我介绍自己的项目，让我特别详细的介绍，包括项目的初衷，如何进行的设计，项目中出现的问题，怎么解决的，项目现在怎么样。<br>
                    提了一句项目中前端用什么，我说异步的框架，我不会，他问你知道Ajax嘛，我说我用过，没细问，不知道啥意思。</p>
                <p>看我用了ActiveMQ，问我为什么用ActiveMQ，为什么不用其他类型的消息队列，我告诉他我不知道。ActiveMQ如何保证发送端和接收端能够发送出去和接收到，以及如何保证的安全性。卧槽？</p>
                <p>看我用了MyBatis，问我#和<span class="katex--inline"><span class="katex"><span class="katex-mathml"><span
                                    class="MathJax_Preview" style="color: inherit; display: none;"></span><span
                                    tabindex="0" class="MathJax" id="MathJax-Element-1-Frame" role="presentation"
                                    style="position: relative;"
                                    data-mathml='<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">&amp;#x7684;</mi><mi mathvariant="normal">&amp;#x533A;</mi><mi mathvariant="normal">&amp;#x522B;</mi><mi mathvariant="normal">&amp;#xFF0C;</mi><mi mathvariant="normal">&amp;#x4E3A;</mi><mi mathvariant="normal">&amp;#x4EC0;</mi><mi mathvariant="normal">&amp;#x4E48;</mi><mi mathvariant="normal">&amp;#x7528;</mi></mrow><annotation encoding="application/x-tex">      &amp;#x7684;&amp;#x533A;&amp;#x522B;&amp;#xFF0C;&amp;#x4E3A;&amp;#x4EC0;&amp;#x4E48;&amp;#x7528;</annotation></semantics></math>'>
                                    <nobr aria-hidden="true"><span class="math" id="MathJax-Span-1"
                                            style="width: 4.11em; display: inline-block;"><span
                                                style="width: 4em; height: 0px; font-size: 102%; display: inline-block; position: relative;"><span
                                                    style="left: 0em; top: -4em; position: absolute; clip: rect(3.05em, 1004em, 4.35em, -1000em);"><span
                                                        class="mrow" id="MathJax-Span-2"><span
                                                            style="width: 4em; height: 0px; display: inline-block; position: relative;"><span
                                                                style="left: 0em; top: -4em; position: absolute; clip: rect(3.05em, 1004em, 4.35em, -1000em);"><span
                                                                    class="semantics" id="MathJax-Span-3"><span
                                                                        class="mrow" id="MathJax-Span-4"><span
                                                                            class="mi" id="MathJax-Span-5"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>的</span></span><span
                                                                            class="mi" id="MathJax-Span-6"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>区</span></span><span
                                                                            class="mi" id="MathJax-Span-7"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>别</span></span><span
                                                                            class="mi" id="MathJax-Span-8"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>，</span></span><span
                                                                            class="mi" id="MathJax-Span-9"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>为</span></span><span
                                                                            class="mi" id="MathJax-Span-10"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>什</span></span><span
                                                                            class="mi" id="MathJax-Span-11"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>么</span></span><span
                                                                            class="mi" id="MathJax-Span-12"><span
                                                                                style='font-family: STIXGeneral,"Arial Unicode MS",serif; font-size: 98%; font-style: normal; font-weight: normal;'>用</span></span></span></span><span
                                                                    style="width: 0px; height: 4em; display: inline-block;"></span></span></span></span><span
                                                        style="width: 0px; height: 4em; display: inline-block;"></span></span></span><span
                                                style="width: 0px; height: 1.12em; overflow: hidden; vertical-align: -0.25em; border-left-color: currentColor; border-left-width: 0px; border-left-style: solid; display: inline-block;"></span></span>
                                    </nobr><span class="MJX_Assistive_MathML" role="presentation"><math
                                            xmlns="http://www.w3.org/1998/Math/MathML">
                                            <semantics>
                                                <mrow>
                                                    <mi mathvariant="normal">的</mi>
                                                    <mi mathvariant="normal">区</mi>
                                                    <mi mathvariant="normal">别</mi>
                                                    <mi mathvariant="normal">，</mi>
                                                    <mi mathvariant="normal">为</mi>
                                                    <mi mathvariant="normal">什</mi>
                                                    <mi mathvariant="normal">么</mi>
                                                    <mi mathvariant="normal">用</mi>
                                                </mrow>
                                                <annotation encoding="application/x-tex"> 的区别，为什么用</annotation>
                                            </semantics>
                                        </math></span>
                                </span>
                                <script id="MathJax-Element-1"
                                    type="math/mml"><math><semantics><mrow><mi mathvariant="normal">的</mi><mi mathvariant="normal">区</mi><mi mathvariant="normal">别</mi><mi mathvariant="normal">，</mi><mi mathvariant="normal">为</mi><mi mathvariant="normal">什</mi><mi mathvariant="normal">么</mi><mi mathvariant="normal">用</mi></mrow><annotation encoding="application/x-tex">的区别，为什么用</annotation></semantics></math></script>
                                </span><span class="katex-html" aria-hidden="true"><span class="base"><span
                                        class="strut" style="height: 0em; vertical-align: 0em;"></span><span
                                        class="mord cjk_fallback">的</span><span class="mord cjk_fallback">区</span><span
                                        class="mord cjk_fallback">别</span><span class="mord cjk_fallback">，</span><span
                                        class="mord cjk_fallback">为</span><span class="mord cjk_fallback">什</span><span
                                        class="mord cjk_fallback">么</span><span
                                        class="mord cjk_fallback">用</span></span></span></span></span>不用#，我当时没想出来，告诉他一个是全文替换，一个是模糊匹配。后来说是防止注入攻击，然后我就马后炮了一下。
                </p>
                <p>提到MyBatis，问我直到的数据的索引的数据结构，我说有四种，常用的是B ，还有哈希索引，但是哈希局限性太大，不常用。问我知道B-嘛，我说知道，就问我什么用B-，我说MongoDB，然后他问我B
                    和B-的区别，我和他说两个都是多叉树，区别在于一个非叶子节点上存数据一个不存，也就是说会影响高度。</p>
                <p>问我知不知道volatile关键字，知道，就问我这个东西是干嘛用的，然后我把原理和他讲了一遍。问我多个线程如何按照顺序进行启动，我不造啊，我和他说我之前用过的方式都是Thread.sleep()，好尴尬。后来看好像是join，他以为我不知道这个关键字。
                </p>
                <p>问我Spring用在什么地方，我就和他说每个地方都用，IoC和AOP，问我Spring默认是单例还是多例，我说单例，然后问我servlet是单例还是多例，我说是一个请求一个线程，然后居然答了多例，我肯定是疯了。然后问我知不知道ThreadLocal，我说再Spring里面见到过，问我作用，我说是为每一个线程复制一个对象的副本，问我线程安全吗，我说线程私有那肯定线程安全啊。
                </p>
                <p>问我知道什么设计模式，我说单例、工厂、装饰者、代理、建造者、模板方法，他觉得太少了，我就说还有策略。问我单例的写法，我就举了饿汉和三种懒汉。<br>
                    问我GET和POST的区别，讲道理记不清了，只记得一个在请求头一个在请求体里面，然后觉得太少，就说在REST下，GET是幂等且耦合的，是获取资源的信息，POST是对资源进行添加。</p>
                <p>问了两个简单的算法题，一个是查找链表倒数第k个节点，一个是判断是否交叉并且在哪里交叉，比较简单，装作自己没刷过这些题，还嗯了一会。</p>
                <p>之后说数据库，我说MySQL，他问我视图，这尼玛是我最坑的一块啊，问我视图的作用，我说是保证安全，将其中一部分的字段提供，然后他问我确定嘛，然后我！改！了！我说是对使徒的修改就会将操作映射到不同的表里，相当于同时修改多个数据表。
                </p>
                <p>确实修改视图会修改基本表</p>
                <p>总结：<br>
                    感觉有点凉，最简单里反而没答上，绝望。我问要学习建议，他说没有；我问他你问的MyBatis和ActiveMQ我没深入了解，是不是要继续深入学习一下这方面，他说你毕竟也才用了一年，然后说了下#和$的问题；我问他说觉得怎么样，他说比最近面的其他人来比还可以，让我一周之内等消息。感觉有点凉。
                </p>
                <p>作者：不能停<br>
                    链接：https://www.nowcoder.com/discuss/68503?type=2&amp;order=3&amp;pos=962&amp;page=1<br>
                    来源：牛客网</p>
                <p>先是介绍自己，我说了一下自己的情况，项目实习经历。问到我实习用到了什么框架，因为我们公司的不是开源的我就讲了讲大概的，说到rpc的调用，因为本身理解的不够透彻就直接说了这个不是很清楚。</p>
                <p>说了它是nio传输。说到学校做过的项目，用到了struts2 hibernate面试官问spring用了么，我说项目里没用，但自学了。</p>
                <p>因为当时自学了，后来没怎么用，spring这部分大概知道怎么用的，知识细节确实忘了，面试官问到springmvc和struts2的区别，我就讲了struts是管理的action继承了actionsupport我们用的是xml去管理的，配置不太方便，springmvc是controller管理的，
                </p>
                <p>使用注解，其实这两个都可以使用注解也可以使用xml去管理，然后struts2是基于filter实现的，springmvc是servlet实现的，然后问到了object的方法有哪些，一时糊涂只想起来了wait，问三次握手，记得细节模糊，答得不太好，问了点数据库知识，问我有没有用到having语法，答没有…记得的有这些。
                </p>
                <p>作者：.QvQ.<br>
                    链接：https://www.nowcoder.com/discuss/68496?type=2&amp;order=3&amp;pos=963&amp;page=1<br>
                    来源：牛客网</p>
                <p>全程问项目，准备的没问几个。<br>
                    1.数据库分库分表。<br>
                    2.索引为什么快。<br>
                    3.快排。<br>
                    4.jvm内存分布</p>
                <p>总共面了60分钟40项目，项目是个小项目，但是优化各方面想的比较周全。<br>
                    但是也不排除他就是想找个理由把我挂了吧… （面试官非常nice，第一次面试有点紧张，和我一样的小伙伴大家一起加油吧，比赛才刚刚开始，该有的offer一定会有的！）</p>
                <p>作者：我倾尽一生，囚你无期<br>
                    链接：https://www.nowcoder.com/discuss/68447?type=2&amp;order=3&amp;pos=964&amp;page=1<br>
                    来源：牛客网</p>
                <p>3月7号下午5点半接到阿里电话，开始面试。持续45分钟。自己具体回答的也还行。面试官没明说情况，但提醒我保持后续电话畅通。应该是过了，可是已经过去3天，简历状态还是 简历评估中。<br>
                    分享一下我一面的具体情况，有二面经验的可以私聊交流交流。谢谢。</p>
                <p>自我介绍<br>
                    说说你的项目吧<br>
                    遇到过哪些问题，怎么解决的</p>
                <p>maven中两个冲突包依赖其他包，怎么处理<br>
                    检查依赖树，exclude。<br>
                    pom.xml中有哪些配置</p>
                <p>string,stringbuilder,stringbuffer</p>
                <p>string中加号连接符是怎么执行的</p>
                <p>string为什么是不可变性</p>
                <p>内存模型</p>
                <p>GC原理</p>
                <p>set和list</p>
                <p>hashmap底层原理，存取过程</p>
                <p>currenthashmap底层原理，安全性</p>
                <p>程序中为什么要使用多线程</p>
                <p>线程是不是越多越好，一般设置多少个</p>
                <p>电脑CPU为4…。适合设置多少个线程<br>
                    用过哪些创建线程方法</p>
                <p>callable原理</p>
                <p>谈一谈对spring的理解<br>
                    spring实现原理<br>
                    设计模式还了解哪些，解释一下<br>
                    http状态码<br>
                    cookie和session区别<br>
                    session原理<br>
                    sessionID除了放cookie还可以放在哪<br>
                    url和body里<br>
                    数据库四大特性<br>
                    事务隔离级别<br>
                    可重复读是怎么实现的，底层原理<br>
                    数据库优化<br>
                    哪些地方适合加索引<br>
                    排序算法及时间复杂度<br>
                    解释归并算法，时间复杂度，是否稳定</p>
                <p>10000个数，找出最大的10个。用什么算法及时间复杂度。堆排序具体怎么实现。<br>
                    小顶堆，不断调整即可。</p>
                <p>你有什么想问的。</p>
                <p>作者：俊雪恋<br>
                    链接：https://www.nowcoder.com/discuss/68289?type=2&amp;order=3&amp;pos=976&amp;page=2<br>
                    来源：牛客网</p>
                <p>阿里一面<br>
                    1、自我介绍</p>
                <p>2、全程怼项目，问的及其细，包括你为什么选择这种方案来实现，具体怎么存储怎么做的，相当细，遇到这类面试官，项目不够熟，就会翻车了。</p>
                <p>3、redis原子操作怎么用比较好</p>
                <p>Redis所有单个命令的执行都是原子性的。<br>
                    redis 实现事务的原理</p>
                <ol>
                    <li>批量操作在发送 EXEC 命令前被放入队列缓存</li>
                    <li>收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令都不会被执行</li>
                    <li>在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中</li>
                </ol>
                <p>4、消息队列会吗？<br>
                    阿里二面<br>
                    操作系统模块：<br>
                    1、说一下并行和并发的区别</p>
                <p>2、你知道进程吗？有进程为何还有线程？<br>
                    1 进程太重了，一个程序要支持多个任务，都开进程开销太大，而且不能共享数据。<br>
                    3、操作系统是如何调度进程呢的</p>
                <p>4、比如linux下我打开一个文件调用read函数，整个过程说的越<br>
                    用户缓冲区到内核缓冲区，read操作，阻塞等待系统调用完成，当然io操作需要磁盘寻道，内存读取数据，写入缓冲区，调用返回</p>
                <p>5、同步异步阻塞非阻塞IO详细越好。</p>
                <p>其他记不起来了。其实这些扩展开来就能说很多，就包含文件系统，进程管理和调度，就差内存管理机制了，我自己说了，虚地址保护模式。<br>
                    网络模块：<br>
                    TCP报文格式</p>
                <p>TCP和UDP</p>
                <p>拥塞控制</p>
                <p>超时重传</p>
                <p>三次握手</p>
                <p>滑动窗口</p>
                <p>常见协议的端口号</p>
                <p>数据库模块：<br>
                    索引数据结构</p>
                <p>索引优化</p>
                <p>存储引擎</p>
                <p>事务（spring框架如何实现事务的呢）</p>
                <p>分库分表</p>
                <p>Java模块：</p>
                <p>hashmap<br>
                    Arraylist和linkedlist<br>
                    voliate</p>
                <p>线程池,如何根据CPU的核数来设计线程大小，如果是计算机密集型的呢，如果是IO密集型的呢？<br>
                    1 计算密集型线程执行较慢，不需要太多线程，只需要发挥多核能力即可，一般设为核心数</p>
                <p>2 io密集型，时间消耗在io上，应该并发多线程以提高cpu利用率<br>
                    countdownlatch和CyclicBarrier底层实现原理<br>
                    共享锁，lock和condition</p>
                <p>线程状态以及API怎么操作会发生这种转换</p>
                <p>JVM：<br>
                    他说只问三个问题，<br>
                    1、垃圾什么时候被回收<br>
                    2、是怎么回收的呢</p>
                <p>3、忘了。。。。<br>
                    分布式：<br>
                    1、redis</p>
                <p>2、分布式事务解决，你知道我们阿里巴巴是怎么做的吗？<br>
                    TCC和rocketmq事务消息。<br>
                    3、消息队列<br>
                    kafka<br>
                    4、分库分表<br>
                    mycat<br>
                    5、CAP<br>
                    暂时只能记起这么多<br>
                    明天醒了再补，时长1小时17分钟。你打住我知道你的掌握程度了期间这句话说了很遍。我知道了，你不用说的这么详细。我们不在这个上面纠缠了，下一个。<br>
                    阿里三面<br>
                    自我介绍<br>
                    hashmap</p>
                <p>红黑树</p>
                <p>微信附件人这个功能怎么实现的<br>
                    如果实现类似微信附近的人功能：<br>
                    第一种可以使用redis-geo扩展；<br>
                    第二种可以使用mysql5.7的geo扩展；<br>
                    第三种可以使用es的geo扩展 ；<br>
                    第四种可以使用百度的API或者微信的API；<br>
                    第五种可以使用Lucene的高级特性；<br>
                    实现原理：坐标 内切圆 找点</p>
                <p>项目问的很多</p>
                <p>就聊了20分钟</p>
                <p>作者：wljn<br>
                    链接：https://www.nowcoder.com/discuss/68249?type=2&amp;order=3&amp;pos=978&amp;page=1<br>
                    来源：牛客网</p>
                <p>1jvm内存模型说一下</p>
                <p>2缺页机制能说一下吗<br>
                    发出缺页中断，执行中断处理程序，进行页面调度。<br>
                    3mysql隔离机制，索引，mysql架构</p>
                <p>4spark sql源码看过吗？</p>
                <p>5说一下rnn梯度消失的原理，怎么解决的</p>
                <p>6你的模型存在什么问题？（这个面试官感觉不太懂，强行问的）</p>
                <p>7算法题 链表的反转 递归非递归 多重背包</p>
                <p>8你有什么问题要问我吗？</p>
                <p>作者：风雨雾凇<br>
                    链接：https://www.nowcoder.com/discuss/68232?type=2&amp;order=3&amp;pos=980&amp;page=2<br>
                    来源：牛客网</p>
                <p>刚刚经历了人生中的第一次面试，感觉多半是要凉了，现在把问题总结一下：</p>
                <ol>
                    <li>
                        <p>自我介绍</p>
                    </li>
                    <li>
                        <p>TCP三次握手和四次挥手</p>
                    </li>
                </ol>
                <p>追问：<br>
                    time_wait状态必须等待多长时间：(答不上来)<br>
                    2MSL</p>
                <p>MSL是Maximum Segment Lifetime的英文缩写，可译为“最长报文段寿命”，它是任何报文在网络上存在的最长的最长时间，超过这个时间报文将被丢弃。</p>
                <p>我们都知道IP头部中有个TTL字段，TTL是time to
                    live的缩写，可译为“生存时间”，这个生存时间是由源主机设置设置初始值但不是但不是存在的具体时间，而是一个IP数据报可以经过的最大路由数，每经过一个路由器，它的值就减1，当此值为0则数据报被丢弃，同时发送ICMP报文通知源主机。
                </p>
                <p>RFC793中规定MSL为2分钟，但这完全是从工程上来考虑，对于现在的网络，MSL=2分钟可能太长了一些。因此TCP允许不同的实现可根据具体情况使用更小的MSL值。TTL与MSL是有关系的但不是简单的相等关系，MSL要大于TTL。
                </p>
                <ol start="3">
                    <li>
                        <p>b+树（答不上来），提了下红黑树，问用半分钟回答红黑树的旋转到底是怎样的？<br>
                            B树和B+树的关键字都比分支少一个</p>
                    </li>
                    <li>
                        <p>mysql隔离级别 不会</p>
                    </li>
                    <li>
                        <p>继续提问mysql索引有哪些 答不上来<br>
                            主键，唯一，全文，联合索引，普通索引</p>
                    </li>
                    <li>
                        <p>快排时间复杂度，什么时候时间复杂度最高</p>
                    </li>
                    <li>
                        <p>操作系统分页、分段是啥 不会</p>
                    </li>
                </ol>
                <p>物理分页，页面调度，分段是逻辑分段</p>
                <ol start="8">
                    <li>
                        <p>垃圾回收机制 不会</p>
                    </li>
                    <li>
                        <p>jvm内存模型。</p>
                    </li>
                    <li>
                        <p>平时开发的时候遇到哪些技术难题，怎么解决的？</p>
                    </li>
                    <li>
                        <p>有什么问题要问的吗？<br>
                            总结了一下，发现过半的问题还是答不上来，主要是平时的准备太少还有中午投的简历下午就有电话过来面试了，下次还是好好准备在去投简历吧。<br>
                            解答：http://blog.csdn.net/qq_33850908/article/details/79491159</p>
                    </li>
                </ol>
                <p>作者：wljn<br>
                    链接：https://www.nowcoder.com/discuss/68218?type=2&amp;order=3&amp;pos=982&amp;page=1<br>
                    来源：牛客网</p>
                <p>项目<br>
                    java多线程编程</p>
                <p>redis hyperloglog原理，为什么要用它</p>
                <p>spark kafka的offset为什么要存在mysql理</p>
                <p>虚拟内存概念</p>
                <p>算法题 将一个四则表达式变为后缀波兰表达式 比如1+5<em>2变为125</em>+</p>
                <p>作者：sakura1027<br>
                    链接：https://www.nowcoder.com/discuss/68199?type=2&amp;order=3&amp;pos=987&amp;page=2<br>
                    来源：牛客网</p>
                <p>一面：<br>
                    1.自我介绍一下，然后问你最擅长哪一方面(我说虚拟机、集合)</p>
                <p>2.他说HashMap我现在都不敢问了，出过很多笑话，很多人都是背的，自己没办法判断是看的还是背的</p>
                <p>3.简单说下HashMap的get方法实现</p>
                <p>4.HashMap数组的第一个元素存的是什么(我不知道然后他说HashMap可以存’呐亩’吗，我听成能不能存enum，我说可以可以能存Integer，String，enum，然后他说是null，不是enum…)
                </p>
                <p>5.HashMap和Hashtable的区别(线程安全不安全，能否存null，数组初始化容量，扩容不一样，elements方法hashcode方法)</p>
                <p>6.里面的hashcode有什么区别(HashMap多了和hashcode&gt;&gt;&gt;16的一次异或，这个看过和他扯了好久好久，扯到为什么2的整次幂反正扯了一大堆)</p>
                <p>7.Hashtable在null的处理是怎样的</p>
                <p>8.线程的几种状态(运行阻塞就绪，他说还有其他的吗，我说挂起？，他说线程生命周期什么的)</p>
                <p>9.这些状态之间怎么转换的，哪些方法转换</p>
                <p>10.一个线程连着调用start两次会出现什么情况(这个讨论了好久好久，他说给你设计这个start你怎么处理这种情况，直接懵逼…提示结合那个线程状态机制想下)报异常。</p>
                <p>11.多线程这块对哪些熟悉(我吓得瑟瑟发抖，毕竟简历上写的熟悉，但自己几斤几两还是知道的，就是知道synchronized和volatile，ConcurrentHashMap，CopyOnWriteArrayList这些等等…还连忙补了一句，这些并发容器只是了解一点，没看过源码，之前打算看ConcurrentHashMap的源码但是6000行可能会看的一知半解就还没看)
                </p>
                <p>12.synchronized和lock的区别</p>
                <p>13.由于我说了一般unlock放在finally里面，他就问try后面一定要跟catch吗，我说可以不跟finally但是一定要跟catch，他说try后面不能跟catch是你在书上看的还是怎么的，我说我从没见过try后面不跟catch的，再说try就是为了捕获潜在的异常，<br>
                    没有catch怎么抓到抛出的异常，他说我不能try…finally吗。我说我没见过，他说那这个问你也不合适…</p>
                <p>14.lock看过多少</p>
                <p>15.Java里面用过哪些包(我说lang util juc
                    math…他说util除了用过集合还用过哪些，我说Arrays、Collections，他说有哪些方法，我说排序二分查找这些，他说Collections有用过吗，里面的排序接口用过吗，答了之后又问如果是要升序里面是写a-b还是写b-a)b
                    - a。</p>
                <p>16.String是可变的吗，答final数组不可变，问是final的什么数组，答char</p>
                <p>17.String s="abc"和String s=new String(“abc”)区别，然后撤常量池还扯String那个intern()方法</p>
                <p>18.StringBuffer和StringBuilder区别</p>
                <p>19.run方法里面有个StringBuilder线程安全吗(这也扯了好久好久，我没转过弯来，他就提示哪些会出现线程不安全的问题，我说竞态条件，什么i++读取-修改-写入，或者单例懒汉的先判断后执行，然后又回到这个run方法里面的<br>
                    StringBuilder，我又没想出来，他又提示方法区里面的变量存在哪，我说栈啊，递归还容易出现堆栈溢出，他又问存在栈里面的是共享的吗，我说是线程私有的，忽然恍然大悟…可能我一开始就没明白这个题什么意思，面试官真是一步一步提示你，真好…)
                </p>
                <p>20.Java的引用类型你知道吗(我说数组，new XXX都是引用，他说你看过深入理解JVM那本书吗，我说看过其中的内存管理、垃圾回收、类加载这些，类文件结构这些没怎么看，他说那就这个就不问了)</p>
                <p>21.那强引用弱引用这些知道吧(说了下强软弱虚四种引用，然后问我后三种引用的应用场景，这个之前撇过一眼，真的不记得了…回去看了下软引用可以实现缓存，弱引用可以用来在回调函数中防止内存泄露，虚引用能在这个对象被收集器回收时收到一个系统通知。)
                </p>
                <p>22.然后问内存管理，内存管理记得清楚吧，我说之前看过，现在知道大概(打个预防针，防止自己尴尬…)，他说现在忘没忘，那我是能问还是不能问？然后我就笑了下…然后他就问说下JVM内存的分代吧，终于到我装逼了…，扯了好久好久，就把深入理解JVM那本书里面相关的都说了下
                </p>
                <p>23.大对象是哪些(我说大数组和大字符串，他说多大叫非常大，我说好像有个参数能设置大概4MB?不是很清楚，然后就是年龄增长那个机制之类的)</p>
                <p>24.Minor GC和Full GC，又扯了好久，反正基本把第二章第三章里面的内容给问了个遍还问的特别细…</p>
                <p>25.JVM里面的参数知道哪些，默认大小是多少，我说只知道Xmx Xms
                    Xss这几个，他说你猜这个中间的m是什么意思，我说是max,min?可又感觉不是…他说其实他也不知道，就是看看我的想象能力，他说他猜得是memory，还有这种操作…然后问Xmn是什么，答不知道…，问你在猜猜…<br>
                    年轻代空间</p>
                <p>26.G1停顿吗，CMS回收步骤</p>
                <p>27.CMS为什么会停顿，停顿时间(我说如果不停顿那个GC Roots没办法进行下去，必须停一下等着GC Roots遍历完成，就和你妈给你打扫卫生时，你肯定不能还扔垃圾，肯定要停下来一样)</p>
                <p>28.类加载了解吗(扯了一堆顺便说了双亲委派机制，他问为什么要每次从上往下加载？好处是什么？我说比较安全…防止重复类加载…也不知道扯得对不对)</p>
                <p>29.数据结构掌握程度怎么样？(再次瑟瑟发抖，面试官说链表我能问吗？问怎么判断两个单链表是否相交…就这题他提示我好久，最后还是没想出来，就是这么的渣…他说直接判断最后一个节点是否相交就好，我说是不是类似一个竹子从中间砍了一点，然后前面分叉，后面相交这样，他说对对对，是这样的)
                </p>
                <p>30.数据库熟悉吗(我把我知道的全说出来了，然后说除了这些都不会了，他说那我就不问了)</p>
                <p>31.项目这些框架用到什么程度，看过源码吗</p>
                <p>32.说说项目(因为是自学，我就直接说这个项目是跟网上的教程一步一步敲得，自学弄哪些高并发分布式的项目也不大现实。说说你写在简历上的项目亮点，我说处理了横向越权、纵向越权的情况，具体说了之后，</p>
                <h2><a name="t2"></a><a
                        id="1001000AOPSpring_MVC&#10;33Bugdubbozookeeper&#10;9740&#10;_3228"></a>他说，如果现在界面有个按钮给你，你怎么保证权限控制，答了之后，他说如果有100个1000个这样的呢，我说能不能用AOP把它分离开来这样弄，他没说行还是不行，然后问我聊聊Spring
                    MVC吧，答了之后又问你知道有个过滤器吧，答了之后，他说其实是用过滤器来处理刚才提的那个问题的，我说对对对，就是类似过滤器处理全局编码那样…反正又是一顿马后炮…)<br>
                    33.研究生期间周围同学，专业啊，反正开始聊人生了，有没有论文(本渣属于无论文、无比赛、无奖学金的三无人员)，你的优势？举个栗子。你是从研究生期间才开始写代码的吗？写了大概多少行。平时除了学习，课余时间干什么(差点就脱口而出玩游戏，还好忍住了…)。每天学多久…项目过程中有没有什么头痛的东西…你有没有遇到一个Bug找了好多天都没找出来的经历…你有什么问题要问我？对我技术方面有什么建议？dubbo，zookeeper这些框架需要看吗？这一面是一面还是二面？他说只是一面，之前的那个只是简历评估面…<br>
                    全程97分钟，面试官说没太注意时间，正常40分钟就要解决的。面完之后我说的都口干舌燥了，感觉身体被掏空…<br>
                    最后说一句，就喜欢这种问你最擅长什么，这个东西我是能问还是不能问的面试官，虽然答得一般但还是五星好评…</h2>
                <h2><a name="t3"></a><a name="t3"></a><a id="_3234"></a>变成面试中了…</h2>
                <h2><a name="t4"></a><a name="t4"></a><a id="_3236"></a>面试状态从简历评估中变成了待安排面试什么鬼？难不成这面只是简历面吗？</h2>
                <p>简历面：<br>
                    面试官上来介绍了他们部门的业务，问我感不感兴趣，我当然感兴趣了，然后开始疯狂输出我…</p>
                <ol>
                    <li>
                        <p>起手式：Object类有哪些方法？</p>
                    </li>
                    <li>
                        <p>wait方法能不能被重写，wait能不能被中断</p>
                    </li>
                    <li>
                        <p>里面哪些方法能被重写</p>
                    </li>
                    <li>
                        <p>hashcode方法有什么用</p>
                    </li>
                    <li>
                        <p>HashSet方法里面的hashcode存在哪(我说类似HashMap存在Node里面，他还是问了我好久，没看过源码很虚)<br>
                            Node里的hash值</p>
                    </li>
                    <li>
                        <p>一个对象的id为1，通过setId(2)改为2，HashSet里面有几个对象，这问了好久好久，没明白他什么意思<br>
                            一个对象</p>
                    </li>
                    <li>
                        <p>线程有几种状态，创建线程的几种方法</p>
                    </li>
                    <li>
                        <p>哪些方法能使线程从运行态变为阻塞态</p>
                    </li>
                    <li>
                        <p>说说线程池，线程池中一个线程执行完任务后处于那种状态</p>
                    </li>
                    <li>
                        <p>Thread类的interrupt,interrupted,isInterrupted方法的区别<br>
                            interrupt改变中断标识位，interrupted改变并返回标识位，isInterrupted只返回标识位</p>
                    </li>
                </ol>
                <p>一般通过轮询标识位，标识位改变时throw interruptexception ，然后我们通过catch interruptexception的方法来执行中断。</p>
                <ol start="11">
                    <li>
                        <p>rt.jar被什么类加载器加载，什么时间加载<br>
                            启动类加载器(Bootstrap ClassLoader)：负责加载 JAVA_HOME\lib
                            目录中的，或通过-Xbootclasspath参数指定路径中的，且被虚拟机认可（按文件名识别，如rt.jar）的类。<br>
                            扩展类加载器(Extension ClassLoader)：负责加载 JAVA_HOME\lib\ext 目录中的，或通过java.ext.dirs系统变量指定路径中的类库。<br>
                            应用程序类加载器(Application ClassLoader)：负责加载用户路径（classpath）上的类库。</p>
                    </li>
                    <li>
                        <p>自己写的类被什么加载，什么时间加载<br>
                            appclassloader加载，jvm启动时加载，也就是运行时</p>
                    </li>
                    <li>
                        <p>自己写的两个不同的类是被同一个类加载器加载的吗？为什么？<br>
                            是的。都是appclassloader</p>
                    </li>
                    <li>
                        <p>CPU能不能直接和二级缓存打交道，接下来一顿问…</p>
                    </li>
                </ol>
                <p>可以的，主不过80%走一级缓存，20%走二级缓存<br>
                    　二级缓存是CPU性能表现的关键之一，在CPU核心不变化的情况下，增加二级缓存容量能使性能大幅度提高。而同一核心的CPU高低端之分往往也是在二级缓存上存在差异，由此可见二级缓存对CPU的重要性。CPU在缓存中找到有用的数据被称为命中，当缓存中没有CPU所需的数据时（这时称为未命中），CPU才访问内存。从理论上讲，在一颗拥有二级缓存的CPU中，读取一级缓存的命中率为80%。也就是说CPU一级缓存中找到的有用数据占数据总量的80%，剩下的20%从二级缓存中读取。由于不能准确预测将要执行的数据，读取二级缓存的命中率也在80%左右（从二级缓存读到有用的数据占总数据的
                    16%）。那么还有的数据就不得不从内存调用，但这已经是一个相当小的比例了。目前的较高端CPU中，还会带有三级缓存，它是为读取二级缓存后未命中的数据设计的—种缓存，在拥有三级缓存的CPU中，只有约5%的数据需要从内存中调用，这进一步提高了CPU的效率，从某种意义上说，预取效率的提高，大大降低了生产成本却提供了非常接近理想状态的性能。除非某天生产技术变得非常强，否则内存仍会存在，缓存的性能递增特性也仍会保留。
                </p>
                <ol start="15">
                    <li>
                        <p>三次握手</p>
                    </li>
                    <li>
                        <p>网络编程会吗</p>
                    </li>
                    <li>
                        <p>socket中accept什么用<br>
                            阻塞等待请求到来</p>
                    </li>
                    <li>
                        <p>两个不同ip地址的计算机之间如何通信<br>
                            如果在一个局域网，那么直接通过2层通信，如果不在一个局域网，那么通过路由器路由再进行2层通信</p>
                    </li>
                    <li>
                        <p>项目中用过Spring吗</p>
                    </li>
                    <li>
                        <p>Spring优点哪些，源码看过吗</p>
                    </li>
                    <li>
                        <p>SpringMVC怎么配置的，xml文件怎么加载的(问了下是要说源码)，一次HTTP请求的过程(其实不是问这个的，它问的什么我没听懂，我说是不是SpringMVC的请求执行过程，他说不是)
                        </p>
                    </li>
                </ol>
                <p>http请求到达，注册io事件，等待处理，包装请求转化为request，然后到达指定的方法处理器。执行并返回。</p>
                <ol start="22">
                    <li>
                        <p>数据库连接池用过吗，来说一说<br>
                            一般用一个容器保存多个连接，可以复用，类似线程池。</p>
                    </li>
                    <li>
                        <p>项目中的MySQL、Nginx这些都是自己配置的吗<br>
                            一部分是</p>
                    </li>
                    <li>
                        <p>有什么想问我的？</p>
                    </li>
                </ol>
                <p>总共47分钟，被问懵逼了，但不得不说面试官的态度一直很好，不会的问题会不断给你提示（然而学渣给再多的提示也答不出来，这TM就很尴尬了），哎越面越感觉自己越菜，只能为阿里秋招攒波人品了…</p>
                <p>作者：Small_New_KeKe<br>
                    链接：https://www.nowcoder.com/discuss/67705?type=2&amp;order=3&amp;pos=1002&amp;page=1<br>
                    来源：牛客网</p>
                <p>先问了在内存中查询数据和在数据库中查询数据的区别</p>
                <p>然后问了数据事务ACID以及数据库隔离级别，脏读，不可重复读，幻读的解决方案</p>
                <p>接下来问了类加载机制（Bootstrap，双亲委派，运行时常量池），JVM内存分配（堆栈，垃圾回收）</p>
                <p>设计模式（单例，观察者，装饰者，代理，工厂）</p>
                <p>然后虚拟内存（不会），网络四层结构（不会）</p>
                <p>问了spring的MVC（我只会这个），接下来可能问IOC，AOP，事务的注入，Spring一致性原理，注解什么的，我都没仔细看，你可以看看</p>
                <p>好像没了，时间到了,他说够了</p>
                <p>作者：Yangge<br>
                    链接：https://www.nowcoder.com/discuss/67251?type=2&amp;order=3&amp;pos=1019&amp;page=1<br>
                    来源：牛客网</p>
                <p>自我介绍，技术栈介绍</p>
                <p>2.那前端怎么异步呢？（我说可以轮讯，或者用socket.io建起长连接通信）</p>
                <p>3.ArrayList底层，扩容</p>
                <p>4.很多很多个数，找到前十个（分治，堆排序）</p>
                <p>5.堆排序的时间复杂度，怎么算出来的</p>
                <p>6.CountDownLatch(我居然忘记这玩意叫啥了，我就说java有这么一个东西，可以解决这个问题，或者也可以用信号量机制来)</p>
                <p>7.HTTP和TCP</p>
                <p>8.TCP关闭连接四次挥手，为啥</p>
                <p>9.ArrayQueue和LinkedQueue（这里没答好，他问“ArrayQueue相比 LinkedQueue”有啥好处，真不知道该答什么，难度是占用空间小？最后直接说了不知道o(╥﹏╥)o）
                </p>
                <p>持续18分24秒<br>
                    感觉凉了</p>
                <p>作者：浮生微光<br>
                    链接：https://www.nowcoder.com/discuss/87096?type=2&amp;order=3&amp;pos=11&amp;page=1<br>
                    来源：牛客网</p>
                <p>接上篇网易的面经，说下阿里的，大部门是菜鸟。时间比较长，只记得大概问了哪些点，技术面共4面。</p>
                <p>1面</p>
                <p>先从基础开始</p>
                <p>1 平时用过哪些集合？（重点说了下Hashmap）</p>
                <p>2 刚说到Hashmap非线程安全，为什么？（扩容会有环）</p>
                <p>3 （前面有主动提到HashTable和ConcurrentHashmap）这两者有什么区别？分段锁的具体细节？</p>
                <p>4 （回答Hashmap的时候有提到j8里面用红黑树优化）红黑树原理？</p>
                <p>5 （ConcurrentHashmap有提到j8乐观锁优化）乐观锁原理？（结合项目场景）</p>
                <p>6 NIO用过吗？说下和BIO的区别？</p>
                <p>7 聊一下印象最深刻的项目？（吧啦吧啦一堆）</p>
                <p>8 后面的问题基本围绕项目（有问到nginx和redis，多级缓存）</p>
                <p>2面</p>
                <p>1 说下印象最深刻的项目（吧啦吧啦一堆，大概围绕项目问了4到6个问题，其中负载均衡和缓存重点）</p>
                <p>2 CI了解吗？中文怎么说？假如开发过程中代码集成后发现出错了怎么处理？<br>
                    持续基础</p>
                <p>3 （简历）说下Java的类加载机制？</p>
                <p>4 哪些情况下会触发类加载？</p>
                <p>jvm初始化。自定义类加载器就行加载，加载外部类</p>
                <p>5 JVM模块？堆的分代？</p>
                <p>6 说下Java里面的锁？</p>
                <p>7 问了下设计模式（具体哪种不太记得）</p>
                <p>8 线程池？简单写个连接池？</p>
                <p>9 出了两个简单的题（一个动态规划的，一个环状链表，说了下思路）</p>
                <p>3面（这面印象比较深，问的稍微深一点）<br>
                    开场（前面同事问基础和项目问的比较多，我就问点技术上的）<br>
                    1 Spring事务了解吗？说下你知道的</p>
                <p>2 什么情况下用编程式事务？什么时候用声明式事务？</p>
                <p>业务比较复杂可以用编程式，正常使用声明式就可以了</p>
                <p>编程式事务：所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。<br>
                    声明式事务：管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。<br>
                    显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。<br>
                    声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。
                </p>
                <p>3 事务的隔离级别？传播级别？在什么场景下用？</p>
                <p>4 AOP用过吗？大致说下</p>
                <p>5 AspectJ和Spring的AOP有哪些区别？</p>
                <p>联系<br>
                    我们借助于Spring Aop的命名空间可以将纯POJO转换为切面，实际上这些POJO只是提供了满足切点的条件时所需要调用的方法，但是，这种技术需要XML进行配置，不能支持注解<br>
                    所以spring借鉴了AspectJ的切面，以提供注解驱动的AOP，本质上它依然是Spring基于代理的AOP，只是编程模型与AspectJ完全一致，这种风格的好处就是不需要使用XML进行配置</p>
                <p>所以，如果你希望在Spring bean上采取比较简单的方式应用横切关注点时，并且这些bean没有被标以final修饰符，同时相似的方法也没有标以static或final修饰符时，就使用Spring
                    AOP吧。相比之下，如果你需要在所提到的限制之上应用横切关注点，或者要在POJO上应用关注点，那么就使用AspectJ。你也可能选择同时使用两种方法，因为Spring支持这样。</p>
                <p>面向方面的编程（AOP）
                    是一种编程范式，旨在通过允许横切关注点的分离，提高模块化。AOP提供方面来将跨越对象关注点模块化。虽然现在可以获得许多AOP框架，但在这里我们要区分的只有两个流行的框架：Spring
                    AOP和AspectJ。这里将会帮助你基于一些关键信息，为你的项目选择正确的技术。<br>
                    Spring AOP不同于大多数其他AOP框架。Spring AOP的目的并不是为了提供最完整的AOP实现（虽然Spring
                    AOP具有相当的能力）；而是为了要帮助解决企业应用中的常见问题，提供一个AOP实现与Spring IOC之间的紧密集成。由于Spring AOP是容易实现的，如果你计划在Spring
                    Beans之上将横切关注点模块化，Spring的这一目标将是要点之一。但同样的目标也可能成为一个限制，如果你用的是普通的Java对象而不是Spring
                    beans,并基于此将横切关注点模块化的话。另一方面，AspectJ可用于基于普通Java对象的模块化，但在实施之前需要良好的关于这个主题的知识。</p>
                <p>6 SpringMVC处理请求的流程？</p>
                <p>找到处理器，然后执行方法，渲染页面，返回响应</p>
                <p>7 用过RPC框架吗？说说你对RPC的理解</p>
                <p>rpc需要网络通信比如netty，协议栈基于tcp，可以使用http或者自定义协议，序列化方式可以使用protobuf或者json等。<br>
                    然后还需要服务注册和发现，服务监控，服务化的完整生态</p>
                <p>8 你刚有提到Apach Thrift，说下服务端和客户端基本编码步骤？</p>
                <p>9 说下Thrift的IO模型？</p>
                <p>10 mybatis的延迟加载知道吗？怎么写？批处理怎么写？动态sql？（顺序可能有点乱，记得不是很清楚）</p>
                <p>11 mybatis的占位符？怎么防止sql注入？（算常识了）</p>
                <h1><a name="t5"></a><a id="_3451"></a></h1>
                <p>12 redis的相关的一些问题</p>
                <p>13 你简历上说用过Kafka和Rabbit，区别在哪？什么场景？</p>
                <p>14 Kafka的是写入效率？写到磁盘，为什么能到O（1）？怎么提高消费端的并发？</p>
                <p>零拷贝，并发分发消息，使用推模型</p>
                <p>15 有什么想问我的吗。。。（每次面完都有这句，懒得写了）</p>
                <p>4面</p>
                <p>4面这里不细讲了，主要是问些项目相关的和实习相关的，然后聊些乱七八糟的，之后直接面HR了。</p>
                <p>总结：</p>
                <p>阿里的几轮面试感觉比较重基础和实现的的一些原理，面试官应该有通过气。</p>
                <p>1面是比较重基础，集合基本上是必问了，特别是Hashmap这块的，尽量多了解点，把底层实现搞清楚了里面的东西你甚至能和面试官扯半小时</p>
                <p>2 面基本上是项目为主，有问到一些JVM的东西，还会问些实操，结合简历。</p>
                <p>3 面问技术，简历上写的框架了解的越全越好，有的面试官可能会往深度问，比如问底层原理底层实现，有的面试官可能问的比较全一点。</p>
                <p>作者：梦蓝樱飞<br>
                    链接：https://www.nowcoder.com/discuss/87048?type=2&amp;order=3&amp;pos=13&amp;page=1<br>
                    来源：牛客网</p>
                <p>时间: 47分23秒<br>
                    个人开启了手机通话录音, 所以能清楚地写出这些问题!(最好也把这个功能打开, 事后可以总结呀!)</p>
                <ol>
                    <li>自我介绍</li>
                    <li>在学校里和实习公司里做项目用的什么技术</li>
                </ol>
                <p>Java基础<br>
                    3. Java读取一个文件, 有哪些方法, 考虑性能, 用哪一个类</p>
                <ol start="4">
                    <li>
                        <p>BIO, NIO, AIO区别</p>
                    </li>
                    <li>
                        <p>NIO的组件, Selector (这个忘记了, 一脸懵逼!)</p>
                    </li>
                    <li>
                        <p>什么是序列化, IO的序列化方式, 为什么需要序列化(包括在网络传输的情况下)</p>
                    </li>
                    <li>
                        <p>Error和Exception区别</p>
                    </li>
                    <li>
                        <p>RuntimeException和非RuntimeException区别</p>
                    </li>
                    <li>
                        <p>什么叫线程安全, 保证线程安全的方法</p>
                    </li>
                    <li>
                        <p>加锁的方式, synchronized作用在方法上和代码块区别</p>
                    </li>
                    <li>
                        <p>synchronized(this)和synchronized(Xx.class)区别</p>
                    </li>
                </ol>
                <p>Web方面:<br>
                    12. Spring AOP实现原理</p>
                <ol start="13">
                    <li>
                        <p>一个页面, 一个提交按钮, 如何防止重复提交, 我说验证码, 还有其它方式吗?<br>
                            token</p>
                    </li>
                    <li>
                        <p>ajax实现跨域请求(前端或者后台实现方法)</p>
                    </li>
                    <li>
                        <p>cookie和session区别</p>
                    </li>
                    <li>
                        <p>forward和redirect区别<br>
                            后者是重定向，地址不变。前者是跳转，地址会跟着变。</p>
                    </li>
                </ol>
                <p>数据库(这个全程被怼, 看来这个要好好复习了):<br>
                    这里还有几个问题, 没听清楚, 所以就没写了!<br>
                    17. 你建过索引吗? 建索引的原则</p>
                <ol start="18">
                    <li>
                        <p>索引的类型, 如主键索引</p>
                    </li>
                    <li>
                        <p>查看SQL执行计划</p>
                    </li>
                    <li>
                        <p>有十万条数据, 写SQL语句查询其中某字段较大值的几条数据</p>
                    </li>
                    <li>
                        <p>子查询与关联查询的区别</p>
                    </li>
                </ol>
                <p>JVM<br>
                    22. 你用过的JVM命令有哪些<br>
                    jps，jstack，jmap，jstat<br>
                    23. 如果一个程序发生OOM, 该怎么处理<br>
                    排查内存dump。看堆中有什么大对象持续存活，看看方法区，也检查下gc日志。<br>
                    24. Java 类加载机制</p>
                <ol start="25">
                    <li>
                        <p>为什么使用双亲委派模型</p>
                    </li>
                    <li>
                        <p>JVM内存模型</p>
                    </li>
                    <li>
                        <p>JDK7与JDK8的JVM内存模型区别<br>
                            永久代变成元数据区<br>
                            网络:</p>
                    </li>
                    <li>
                        <p>HTTP1.0与HTTP1.1区别</p>
                    </li>
                    <li>
                        <p>TCP与UDP区别</p>
                    </li>
                </ol>
                <p>最后<br>
                    30. 你有哪些问题要问我的?</p>
                <p>个人总结:</p>
                <ol>
                    <li>
                        <p>当时下午正在实习, 突然接到了杭州的电话, 话说阿里真效率, 应该是前天投的简历;</p>
                    </li>
                    <li>
                        <p>问的都比较基础, 有好多问题, 我之前都复习过了, 没想到这么快就忘记了, 归根到底是没有深入理解其本质;</p>
                    </li>
                    <li>
                        <p>事后发现自己回答地太快了, 有些东西没有说清楚, 估计是有点紧张啊;</p>
                    </li>
                    <li>
                        <p>当时上海这边风真大, 有几个问题, 问了两遍, 硬是没有听清楚, 最后尴尬而不失礼貌地说了句"不知道".</p>
                    </li>
                </ol>
                <p>接下来, 好好复习, 继续总结, 加油!</p>
                <p>作者：七夜zmn<br>
                    链接：https://www.nowcoder.com/discuss/86981?type=2&amp;order=3&amp;pos=15&amp;page=1<br>
                    来源：牛客网</p>
                <p>还热乎的阿里题</p>
                <p>阿里：<br>
                    1.逻辑题；<br>
                    100的阶乘有几个0</p>
                <p>有几个5就有几个0。<br>
                    5 - 95 一共有10个5，而55有两个5，所以有11个0.</p>
                <p>2.list set map 底层使用什么实现的有哪些典型实现</p>
                <p>3.hashmap五个线程~同时put值会发生什么后果</p>
                <p>可能会形成死链</p>
                <p>4.hashmap扩容是怎么扩容的，为什么是2的幂<br>
                    2倍扩容，2的幂，所以哈希值&amp;(2的幂-1）就是去哈希值后几位</p>
                <p>5.concurrenthashmap为什么线程安全，采用了什么措施应对高并发</p>
                <p>6.线程池的参数有什么意义<br>
                    过期时间</p>
                <p>7.定长队列5，最高线程6个，核心3个，100个任务同时请求，怎么处理的</p>
                <p>执行拒绝策略</p>
                <p>8.情景题:按钮点一下后台生成订单，当用户疯狂点的时候怎么正常生成订单</p>
                <p>两者在原理上都是通过session
                    token来实现的。当客户端请求页面时，服务器会生成一个随机数Token，并且将Token放置到session当中，然后将Token发给客户端（一般通过构造hidden表单）。<br>
                    下次客户端提交请求时，Token会随着表单一起提交到服务器端。</p>
                <p>2、应用于“防止表单重复提交”：<br>
                    服务器端第一次验证相同过后，会将session中的Token值更新下，若用户重复提交，第二次的验证判断将失败，因为用户提交的表单中的Token没变，但服务器端session中Token已经改变了。
                </p>
                <p>生成订单时生成一个token，并且设定时间内token不变，不允许重复提交请求。</p>
                <p>9.分布式框架了解吗，nginx了解吗。dubbo了解吗，docker了解吗，数据库了解吗。。（自己简历写的坑）自己作死<br>
                    Nginx负载均衡反向代理<br>
                    dubbo 是rpc框架<br>
                    docker容器</p>
                <p>Docker并不是LXC的替代品，Docker的底层就是使用了LXC来实现的。LXC将Linux进程沙盒化，使得进程之间相互隔离，并且能够控制各进程的资源分配。<br>
                    在LXC的基础之上，Docker提供了一系列更强的功能。</p>
                <p>可移植性<br>
                    Docker定义了一种新的格式，将应用和其依赖环境全部打包到一个单一对象中，这个对象可以在任何安装有Docker的机器上共享，在任何机器上执行这个对象的效果都是一样的。LXC仅仅实现了进程沙盒化，并不能在不同机器上进行移植。Docker将应用的所有配置进行抽象，打包到一个容器中，使得该容器具有可移植性。<br>
                    以应用为中心<br>
                    Docker针对应用的部署做了优化，反映在其API，用户接口，设计原理及文档上面。而LXC仅仅关注容器作为一个轻量级的服务器。<br>
                    自动化构建<br>
                    Docker中支持Dockerfile，将应用的所有依赖项，构建工具和包都以源码的形式写在Dockerfile中，然后Docker可以根据Dockerfile构建镜像。该镜像在任何机器上面运行的效果都一样。<br>
                    版本控制<br>
                    Docker对容器提供了类git的版本控制功能，支持版本回滚等功能。Docker也实现了增量上传和下载的功能，节约了上传和下载时的带宽资源。<br>
                    组件重用<br>
                    一个镜像可以作为基础镜像来创建更多特定的镜像，镜像之间支持多层重用。<br>
                    镜像共享<br>
                    Docker开发了一个Docker Hub，里面包含了各种常用的镜像，非常方便，我们也可以将自己的镜像上传到Docker
                    Hub中。用户也可以在私有环境中搭建自己的Docker仓库，用来满足镜像的内部共享。<br>
                    工具生态系统<br>
                    Docker定义了一个API，用于自动化和本地化容器的创建和部署。已经存在大量的集成了Docker的工具集，例如Deis，mesos，docker-ui，jenkins等等。<br>
                    10.反射能得到方法的参数名吗。int age中的age。为什么得不到<br>
                    不能<br>
                    等了好久的阿里面试。突然来的电话。吓一跳。没准备好。面试小哥哥挺好。自己技术不过关。蓝瘦</p>
                <p>作者：java讨饭员<br>
                    链接：https://www.nowcoder.com/discuss/86741?type=2&amp;order=3&amp;pos=21&amp;page=1<br>
                    来源：牛客网</p>
                <p>部门：中间件<br>
                    时间：1小时3分<br>
                    再次感谢@xzchaoo</p>
                <p>早上刚面完oppo（oppo的面经不敢写，当时面试的时候说要保密，需要的可以私聊下），本来晚上想休息下，结果阿里电话来了（关键我没做测评，以为做了才有），吐槽一下中间件是真的面的难，挂了也认了（我的阿里梦。。。。）
                </p>
                <p>问题：<br>
                    1.项目balabala（20分钟）</p>
                <p>2.redis rdb和aof（redis必问环节）</p>
                <p>3.redis事务</p>
                <p>4.hashmap底层</p>
                <p>5.threadpoolexecutor关键参数解释</p>
                <p>6.blockqueue实现消费者和生产者通过put和take方法，介绍put和take底层实现<br>
                    lock锁，数组队列使用一个锁，链表队列使用两个锁。<br>
                    读写锁使用一个队列<br>
                    7.场景设计：多个线程结束后再运行主线程</p>
                <p>8.原子包的实现</p>
                <p>9.fail-fast原理<br>
                    检查modcount，不符合的话抛出conmodifyexception<br>
                    10.lock和synchronized，涉及可重入锁，锁的优化（偏向锁，轻量级锁，自旋锁的实现细节）<br>
                    偏向锁使用偏向线程号标识。<br>
                    轻量级锁把锁记录复制到对象头，然后替换锁记录为指向对象头的指针，替换成功则加锁成功。<br>
                    自旋锁就是循环请求不加锁，但是会占用cpu</p>
                <p>11.设计一个缓存系统（基于LRU的过期策略）（15分钟）<br>
                    链表。访问时放到链表头，否则先进先出。超过容量时删除尾节点。<br>
                    我们使用的是头插法。反之应该也可以。</p>
                <p>最后一个题真虐！！！</p>
                <p>还有一些我忘了问的啥，这次是真的紧张</p>
                <p>作者：java讨饭员<br>
                    链接：https://www.nowcoder.com/discuss/87308?type=2&amp;order=3&amp;pos=4&amp;page=1<br>
                    来源：牛客网</p>
                <p>蚂蚁金服内推三面<br>
                    私下面过一轮，进入系统后第二轮面试。<br>
                    时间：45分钟<br>
                    部门：中间件<br>
                    中午吃饭，杭州电话，慌的一批，果然题太猛了，连自我介绍都免了，项目也没介绍（可能项目太渣了），直接奔入主题，有的问题记不清了，想到了后面补上。</p>
                <p>1.幻读以及MVCC<br>
                    确实是使用mvcc解决的幻读</p>
                <p>2.1000个列，列的值非0即1，求每一行值大于300的数据行，全部select出来</p>
                <p>3.进程中断<br>
                    interrupt</p>
                <p>4.进程饥饿<br>
                    饥饿一般是由于进程调度算法不合适，比如优先级，最短时间调度等，没能得到调度</p>
                <p>5.动态规划原理以及和分治法区别</p>
                <p>6.二叉树深度求解</p>
                <p>7.spring MVC，spring AOP源码</p>
                <p>8.spring循环引用检测</p>
                <p>9.spring事务传播机制<br>
                    required说明需要开启事务。<br>
                    never表示不开启事务<br>
                    support表示可以开可以不开</p>
                <p>10.可重用锁</p>
                <p>11.double check介绍</p>
                <p>12.java nio，bio，aio，操作系统底层nio实现原理</p>
                <p>13.一个任务分成多个任务，最后汇总计算，不能用fork/join<br>
                    MapReduce，线程池future接收结果</p>
                <p>14.感兴趣的方向</p>
                <p>作者：沉迷于学习无法自拔<br>
                    链接：https://www.nowcoder.com/discuss/87473?type=2&amp;order=3&amp;pos=6&amp;page=1<br>
                    来源：牛客网</p>
                <p>offer已经算是有了，回馈牛客，在牛客网上我也学习到了很多大家分享出来的东西，是时候把自己秋招的面经分享出来积累人品了，最近在做一个人生中最重要的决定，希望结果是好的，攒人品！攒人品！攒人品！重要的话要说三遍！！！
                </p>
                <p>一面，全程一个小时左右：<br>
                    一上来先说自己实习做的项目，然后面试官开始问项目细节，然后又开始说学校里做的项目，这两个加起来就快四十分钟了，因为每个人项目不一样就不介绍跟项目关系太大的，说几个通用型问题</p>
                <p>1：为什么你的缓存更新策略是先更新数据库后删除缓存，讲讲其他的情况有什么问题<br>
                    先更新缓存再更新数据库</p>
                <p>2：两个线程打印1.2.3.4打印到100怎么实现，这里刚开始说的是加锁用生产者消费者来做，后来说了semaphore，感觉后面的才是面试官想要的答案。</p>
                <p>3：spring的aop的实现方式，aspectj和jdk动态代理，cglib动态代理，讲了下实现的原理</p>
                <p>4：hashmap实现原理，把知道的都说出来。</p>
                <p>二面，在周二，也是一个多小时，一来还是说的实习项目，然后直接问问题<br>
                    1.缓存的使用策略和从底层数据库开始往上各个层级中缓存的使用，把你知道的都说出来，这个问题刚开始有点懵逼，后来就从数据库底层原理开始说起，然后讲了缓存的各种使用策略，和这些策略避免的什么问题，这里讲了好久，边说边被追问，里面涉及到各种缓存击穿，缓存穿透，缓存雪崩，互斥锁等内容
                </p>
                <p>穿透就是不走缓存</p>
                <p>雪崩就是大量缓存同时失效</p>
                <p>2.假如双十一等一些促销有高并发访问量要来访问我们的数据，怎么样做到可靠的服务，这个问题我说了很多处理高并发的东西，但是好像不是最终答案，好像是问题没听太明白，不过不影响<br>
                    接下来是项目，也是深挖了好多东西，怼了半天，<br>
                    通用的问题还有：</p>
                <p>1.jvm虚拟机老年代什么情况下会发生gc，给你一个场景，一台4核8G的服务器，每隔两个小时就要出现一次老年代gc，现在有日志，怎么分析是哪里出了问题<br>
                    看一下gc日志，看一下gc频率，位置，时间等</p>
                <p>2.springboot和spring的区别<br>
                    配置方便，内置tomcat<br>
                    3.你是怎么保证你的代码质量和正确性的<br>
                    代码规范，设计模式，以及单元测试</p>
                <p>三面：没有任何基础知识，上来直接问项目，项目问了很多，然后从项目引申到具体的业务场景：<br>
                    1消息队列的生产者消费者中消费者没有收到消息怎么办，消息有顺序比如1.2.3但是收到的却是1.3.2怎么办？消息发过来的过程中损坏或者出错怎么办</p>
                <p>类似tcp滑动窗口的有序传输，超时重传<br>
                    2下单过程中是下订单减库存还是付款减库存，分析一下两者的优劣<br>
                    下单减库存，防止大量失效订单。</p>
                <p>支付减库存，防止恶意下订单<br>
                    3 高并发场景的限流，你怎么来确定限流限多少，模拟场景和实际场景有区别怎么解决，动态改变限流阀值遇到的问题<br>
                    1 根据系统的瓶颈估算。<br>
                    2 压测<br>
                    3 调整限流阈值，应该逐步调整。</p>
                <p>总的来说三场面试都没什么我那看了那么久的基础知识的用武之地，主要还是看你怎么能够把知识和实际情况能够结合起来，毕竟校招，考察的还是一个人的学习能力和一种思维<br>
                    话说最近真的是很纠结，选择比努力重要，衷心希望大家都能找到满意的工作</p>
                <p>作者：Coding_C<br>
                    链接：https://www.nowcoder.com/discuss/87454?type=2&amp;order=3&amp;pos=9&amp;page=1<br>
                    来源：牛客网</p>
                <p>对于一个非计算机专业的弱鸡来说，阿里的一面有点惊心动魄。电话来的很突然，然而第一个电话打来的时候我在和我朋友打电话，然后给挂了。我想会不会凉了。然后就去看电影了，结果第二个电话来的猝不及防<br>
                    话不多说，开始。<br>
                    首先就是自我介绍，然后主要让说一说自己主要开发的项目。然后大概介绍一下基本情况。<br>
                    然后就是问题轰炸环节。<br>
                    1.索引的数据结构(好像是b树吧)</p>
                <p>2.紧接着就问什么是树，二叉树有什么优点，这个我就瞎扯了一通。</p>
                <p>3.然后问我知道哈希吗？问二叉树比哈希牛逼在哪里？各自有什么优缺点，我就从查找和排序上个举了个例子。</p>
                <p>4又接着问了点排序的，问哈希解决冲突有哪些机制。</p>
                <p>5.下面是计算机网络的知识，问TCP和http的区别</p>
                <p>6.http的服务器端和客户端能双向通信吗？<br>
                    可以啊，websocket可以实现向通信</p>
                <p>5.websocket<br>
                    WebSocket
                    规范的目标是在浏览器中实现和服务器端双向通信。浏览器和服务器只需要要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。在此WebSocket
                    协议中，为我们实现即时服务带来了两大好处：互相沟通的Header是很小的-大概只要2Bytes、服务器可以主动传送数据给客户端。目前还只有部分浏览器支持此协议。<br>
                    7.又问了设计模式，问我了模板方法设计模式。</p>
                <p>最后是两个开放题目<br>
                    8.你觉得自己有哪些有点。</p>
                <p>9问我对分布式操作和软件有什么了解，我为了避免尴尬，把自己实习经历又扯了一通。</p>
                <p>总之，一面问的很广，想到什么问什么。另外就是还是需要很扎实的基本功。至少要对自己的岗位基础知识很了解。还有就是随时做好准备，很容易突击，否则就会像我一样一脸懵逼。<br>
                    反正我感觉我凉凉了，祝各位好运！</p>
                <p>作者：奔跑的蛋蛋<br>
                    链接：https://www.nowcoder.com/discuss/87692?type=2&amp;order=3&amp;pos=8&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里巴巴(业务平台技术质量部 测试开发)：</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">一面(2018/7/16 晚上十点 一个小时左右):
1:  自我介绍

2:  HashMap怎么解决Hash冲突的

3:  ConcurrentHashMap怎么解决线程安全

4:  常见的排序有没有了解过

5:  一堆基本有序的数组，用哪种排序效率最高

6:  JDK1.6到JDK1.8 GC上面最大做了什么变化
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li></ul></pre>
                <p>元数据区<br>
                    7: CMS怎么进行垃圾收集的<br>
                    初始标记，并发标记，重新标记，清除<br>
                    8: G1怎么进行垃圾收集的<br>
                    进行内存分块，每个块可能属于一个区。<br>
                    也是经过标记，垃圾集中，然后清除，并且有预测模型<br>
                    9: G1相比于CMS有哪些优势<br>
                    1 会进行内存整理<br>
                    2 空间利用率更高，垃圾集中<br>
                    3 建立gc时间可预测模型<br>
                    10: 哪些情况会导致Full GC<br>
                    1 分配对象失败且空间不足，年轻代，老年代，方法区都有可能。<br>
                    2 cms 多线程分配对象失败或者晋升失败<br>
                    3 预测平均晋升大小大于旧生代的剩余空间<br>
                    11: 新new的对象放在哪里</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">12: 哪些东西放在栈区

13: 双亲委派模型, 有什么好处

14: wait和sleep有什么区别

15: 线程池几个参数

16: 怎么评估线程数大小 

17: 几个线程访问同一个东西，怎么保证安全

18: Spring几个特点说下

19: CGLib有没有了解过

20: Spring支持哪几种切片
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li><li style="color: rgb(153, 153, 153);">8</li><li style="color: rgb(153, 153, 153);">9</li><li style="color: rgb(153, 153, 153);">10</li><li style="color: rgb(153, 153, 153);">11</li><li style="color: rgb(153, 153, 153);">12</li><li style="color: rgb(153, 153, 153);">13</li><li style="color: rgb(153, 153, 153);">14</li><li style="color: rgb(153, 153, 153);">15</li><li style="color: rgb(153, 153, 153);">16</li><li style="color: rgb(153, 153, 153);">17</li></ul></pre>
                <p>aop和aspect</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">21: SpringBoot和Spring有什么区别

22: SpringBoot和Spring启动有什么区别

23: Spring启动生命周期 

24: Spring注解@Resource和@Autowired区别对比  =&gt; 优先级不一样
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li><li style="color: rgb(153, 153, 153);">6</li><li style="color: rgb(153, 153, 153);">7</li></ul></pre>
                <p>@Autowire默认按照类型装配，默认情况下它要求依赖对象必须存在如果允许为null，可以设置它required属性为false，如果我们想使用按照名称装配，可以结合@Qualifier注解一起使用;
                </p>
                <p>@Resource默认按照名称装配，当找不到与名称匹配的bean才会按照类型装配，可以通过name属性指定，如果没有指定name属性，当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象.<br>
                    25: spring @service @controller @componet 三者区别</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">26: Http和Https协议有什么区别，证书了解不

27: 介绍下Redis设计实现

28: Redis的细节源码看过没有
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li></ul></pre>
                <p>数据结构</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">29: Redis分布式缓存
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>codis redis cluster</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">30: 线程在频繁的Full GC 怎么排查

31: JVM一些工具，jps, jmap

32: 你有啥问题
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li><li style="color: rgb(153, 153, 153);">2</li><li style="color: rgb(153, 153, 153);">3</li><li style="color: rgb(153, 153, 153);">4</li><li style="color: rgb(153, 153, 153);">5</li></ul></pre>
                <p>二面(2018/7/19 晚上九点 40分钟左右):<br>
                    1: 自我介绍<br>
                    2: 实习做什么<br>
                    3: 你对哪个语言最熟悉<br>
                    4: Java的内存模型<br>
                    5: 垃圾回收的原理<br>
                    6: 你写过Java的Web系统<br>
                    7: 简单介绍一下你的项目</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">8:  两个有序的数组，合成一个有序的数组，怎么合并效率高 
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>归并<br>
                    9: 淘宝的登陆页面，怎么保证他安全<br>
                    数据库中存储密码的安全性<br>
                    MD5 sha + salt<br>
                    密码在网络中传输的安全性<br>
                    进行加密传输后依然能被轻松攻击，黑客截获后，即使不分析出密文所对应的明文，只要构造相同的http请求使用所谓的“回放攻击”，就能轻松登录用户的账户。<br>
                    解决这种传输中安全问题的终极方案是使用https协议加密传输。只要在客户端输入时密码不被窃取，且ssl协议的私钥安全，这种协议就是安全的。<br>
                    密码在浏览器端输入的安全性（本文暂不讨论）<br>
                    这个就是避免键盘被监控，并且保证密码不可见。</p>
                <p>1 前端保护密码。<br>
                    2 加密传输密码。<br>
                    3 https方式传输</p>
                <pre
                    class="prettyprint"><code class="has-numbering" style="position: unset;" onclick="mdcp.signin(event)">10:  你有最新半年用户的订单，每天的用户订单量有上亿，预测下未来一周哪些商品最容易被购买
<div class="hljs-button signin" data-title="登录后复制"></div></code><ul class="pre-numbering"><li style="color: rgb(153, 153, 153);">1</li></ul></pre>
                <p>抽样统计，日志分析<br>
                    12: 你将来要不要考研<br>
                    13: 下半年实习时间<br>
                    14: 给你说下面试流程[三轮技术面 + hr面]</p>
                <p>一面把我的老底都翻光了，校招真不是跟实习一个级别的。</p>
                <p>有没有老哥做测试开发或者了解测试开发的，值不值得去，一直是后台方向的<br>
                    怕全是测试，大方向错了，就GG了</p>
                <p>作者：WJoe<br>
                    链接：https://www.nowcoder.com/discuss/87736?type=2&amp;order=3&amp;pos=7&amp;page=1<br>
                    来源：牛客网</p>
                <p>阿里就是和其他公司不一样。。。<br>
                    蚂蚁金服中间件一面 时间 55分钟<br>
                    基本上是分布式架构方面的东西<br>
                    1、个人介绍加项目介绍20分钟</p>
                <p>2、微服务架构是什么，它的优缺点？<br>
                    soa体系下更细粒度的拆分，基础是rpc，扩展是服务治理，加强版是容器，计算，资源调度，监控，限流等。<br>
                    3、ACID CAP BASE理论</p>
                <p>4、分布式一致性协议，二段、三段、TCC，优缺点<br>
                    二段死锁<br>
                    三段解决二段问题<br>
                    tcc尝试提交失败补偿。</p>
                <p>5、RPC过程<br>
                    动态代理</p>
                <p>6、服务注册中心宕机了怎么办？<br>
                    zk是集群部署的，可以自动进行选主<br>
                    我们都知道，Zookeeper要安装在奇数个节点，但是为什么？<br>
                    Zookeeper的大部分操作都是通过选举产生的。比如，标记一个写是否成功是要在超过一半节点发送写请求成功时才认为有效。同样，Zookeeper选择领导者节点也是在超过一半节点同意时才有效。最后，Zookeeper是否正常是要根据是否超过一半的节点正常才算正常。这是基于CAP的一致性原理。
                </p>
                <p>zookeeper有这样一个特性：集群中只要有过半的机器是正常工作的，那么整个集群对外就是可用的。也就是说如果有2个zookeeper，那么只要有1个死了zookeeper就不能用了，因为1没有过半，所以2个zookeeper的死亡容忍度为0；同理，要是有3个zookeeper，一个死了，还剩下2个正常的，过半了，所以3个zookeeper的容忍度为1；同理你多列举几个：2-&gt;0;3-&gt;1;4-&gt;1;5-&gt;2;6-&gt;2会发现一个规律，2n和2n-1的容忍度是一样的，都是n-1，所以为了更加高效，何必增加那一个不必要的zookeeper呢。<br>
                    7、微服务还有其他什么组件<br>
                    监控，服务熔断，服务降级，消息总线等。<br>
                    8、分布式架构与微服务的关系<br>
                    更加细粒度，更加注重独立部署，快速迭代，以及独立性。<br>
                    9、你有什么问题要问我的。</p>
                <p>蚂蚁金服二面 昨天晚上9点半打来电话。 时间1小时20分钟<br>
                    什么都问，都是很基础的东西，诶，感觉基础不扎实。。感觉和这位同学是一个面试官。有几个问题是一样的。@java讨饭员<br>
                    上来不用自我介绍，项目介绍，直接开始<br>
                    算法来两道<br>
                    1、各种排序算法、未排序常规数据查找第K大的数，时间复杂度。</p>
                <p>2、二叉树的深度</p>
                <p>操作系统来两道</p>
                <p>3、虚拟内存分页了解不？</p>
                <p>4、进程和线程区别</p>
                <p>数据库来三道</p>
                <p>5、第一二三范式是什么？</p>
                <p>6、一个表一千个列值为true和false，写sql 查询 有300个列值为true的行。<br>
                    不会<br>
                    7、脏读和幻读是什么？</p>
                <p>JVM</p>
                <p>7、什么对象会从新生代晋升到老年代</p>
                <p>多线程<br>
                    8、一个任务分成十个任务，最后汇总计算，不能用fork/join</p>
                <p>9、实习+项目问题，基本是在联想研究院做的东西，还问我为什么不留那。。。</p>
                <p>10、开源框架源码了解不？</p>
                <p>11、数据建模两道、个人题开放性题</p>
                <p>12、你有什么问题</p>
                <p>补充 忘了 安全方面的问题</p>
                <p>13、对安全方面了解多少？</p>
                <p>14、 安全协议有哪些 、https是啥？</p>
                <p>作者：自然醒。<br>
                    链接：https://www.nowcoder.com/discuss/87830?type=2&amp;order=3&amp;pos=6&amp;page=1<br>
                    来源：牛客网</p>
                <p>项目<br>
                    Springmvc请求流程</p>
                <p>Spring IOC，autowired如何实现</p>
                <p>了解其他开源项目吗</p>
                <p>Spring boot</p>
                <p>布隆过滤器</p>
                <p>一致性Hash</p>
                <p>了解dubbo吗，看的源码还是博客</p>
                <p>有debug过吗，怎么debug的</p>
                <p>只面了半个小时。。是不是要挂。。。</p>
                <p>个人公众号：程序员黄小斜</p>
                <p>微信公众号【程序员黄小斜】新生代青年聚集地，程序员成长充电站。作者黄小斜，职业是阿里程序员，身份是斜杠青年，希望和更多的程序员交朋友，一起进步和成长！专注于分享技术、面试、职场等成长干货，这一次，我们一起出发。
                </p>
                <p>关注公众号后回复“2019”领取我这两年整理的学习资料，涵盖自学编程、求职面试、算法刷题、Java技术学习、计算机基础和考研等8000G资料合集。<br>
                    <img alt="在这里插入图片描述" src="https://img-blog.csdnimg.cn/20191230001314394.jpg"><br>
                    ​</p>
                <p>技术公众号：Java技术江湖</p>
                <p>微信公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，专注于 Java
                    相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！</p>
                <p>关注公众号后回复“PDF”即可领取200+页的《Java工程师面试指南》强烈推荐，几乎涵盖所有Java工程师必知必会的知识点。</p>
                <p><img alt="在这里插入图片描述" src="https://img-blog.csdnimg.cn/20191230001322285.jpg"></p>

            </div>
            <div
                data-report-view='{"mod":"1585297308_001","dest":"https://blog.csdn.net/a724888/article/details/81389605","extend1":"pc","ab":"new"}'>
                <div></div>
            </div>
            <link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-60ecaf1f42.css" rel="stylesheet">
            <div
                data-report-view='{"mod":"popu_387","dest":"https://blog.csdn.net/a724888/article/details/81389605","extend1":"pc","ab":"new"}'>
            </div>

            <div class="person-messagebox">
                <div class="left-message"><a href="https://blog.csdn.net/a724888">
                        <img class="avatar_pic" src="https://profile.csdnimg.cn/F/A/4/3_a724888" username="a724888">
                    </a></div>
                <div class="middle-message">
                    <div class="title"><span class="tit "><a href="https://blog.csdn.net/a724888" target="_blank"
                                data-report-click='{"mod":"popu_379","ab":"new"}'>黄小斜</a></span>
                        <!-- 等级，level -->
                        <img class="identity-icon" src="https://csdnimg.cn/identity/blog7.png"> <span
                            class="flag expert">
                            <a href="https://blog.csdn.net/home/help.html#classicfication" target="_blank">
                                <img alt=""
                                    src="https://csdnimg.cn/release/phoenix/template/new_img/identityExpert.png">
                                博客专家
                            </a>
                        </span>
                    </div>
                    <div class="text"><span>原创文章 316</span><span>获赞 1883</span><span>访问量 134万+</span></div>
                </div>
                <div class="right-message">
                    <a class="btn btn-sm  bt-button personal-watch"
                        data-report-click='{"mod":"popu_379","ab":"new"}'>关注</a>
                    <a class="btn btn-sm bt-button personal-messageboard" href="https://bbs.csdn.net/topics/395526998"
                        target="_blank">他的留言板
                    </a>
                </div>
            </div>

        </div>
    </article>

</div>